home *** CD-ROM | disk | FTP | other *** search
/ Aminet 28 / Aminet 28 (1998)(GTI - Schatztruhe)[!][Dec 1998].iso / Aminet / dev / src / CmdListSrc.lha / CommandList / CommandList.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-09-11  |  88.7 KB  |  2,870 lines
  1. #include <exec/types.h>
  2. #include <exec/memory.h>
  3. #include <exec/execbase.h>
  4. #include <dos/dos.h>
  5. #include <dos/dostags.h>
  6. #include <intuition/intuition.h>
  7. #include <intuition/intuitionbase.h>
  8. #include <intuition/gadgetclass.h>
  9. #include <intuition/sghooks.h>
  10. #include <intuition/imageclass.h>
  11. #include <libraries/gadtools.h>
  12. #include <libraries/diskfont.h>
  13. #include <libraries/commodities.h>
  14. #include <libraries/locale.h>
  15. #include <libraries/asl.h>
  16. #include <libraries/altclass.h>
  17. #include <workbench/workbench.h>
  18. #include <workbench/startup.h>
  19.  
  20. #include <string.h>
  21. #include <stdlib.h>
  22. #include <clib/alib_protos.h>
  23. #include <clib/icon_protos.h>
  24. #include <clib/graphics_protos.h>
  25. #include <clib/dos_protos.h>
  26. #include <clib/intuition_protos.h>
  27. #include <clib/gadtools_protos.h>
  28. #include <clib/exec_protos.h>
  29. #include <clib/commodities_protos.h>
  30. #include <clib/locale_protos.h>
  31. #include <clib/wb_protos.h>
  32. #include <clib/diskfont_protos.h>
  33. #include <clib/utility_protos.h>
  34. #include <clib/asl_protos.h>
  35. #include <clib/keymap_protos.h>
  36.  
  37. #define VERSION "1.1"
  38.  
  39. UBYTE *ver="\0$VER: CommandList "VERSION" ("__COMMODORE_DATE__")";
  40.  
  41. /* Locale stuff */
  42.  
  43. struct Library *LocaleBase;
  44. struct Locale *locale;
  45. struct Catalog *catalog;
  46.  
  47. #define CATCOMP_BLOCK
  48. #define CATCOMP_NUMBERS
  49. #include "CommandList_locale.h"
  50. #undef CATCOMP_BLOCK
  51.  
  52. /* slightly modified version of getString() generated by catcomp */
  53.  
  54. char *getString(ULONG MsgID)
  55. {
  56. LONG   *l;
  57. UWORD  *w;
  58. char *builtIn;
  59.  
  60.    l = (LONG *)CatCompBlock;
  61.  
  62.    while (*l != MsgID )
  63.    {
  64.            w = (UWORD *)((ULONG)l + 4);
  65.            l = (LONG *)((ULONG)l + (ULONG)*w + 6);
  66.    }
  67.    builtIn = (char *)((ULONG)l + 6);
  68.    if (LocaleBase)
  69.            return (GetCatalogStr(catalog, MsgID, builtIn));
  70.    return(builtIn);
  71. }
  72.  
  73.  
  74. /* Commodity stuff */
  75.  
  76. struct NewBroker newbroker = {    NB_VERSION,
  77.                                   "CommandList", /* string to identify this broker */
  78.                                   "CommandList "VERSION" ("__COMMODORE_DATE__")",
  79.                                   "", /* description set later */
  80.                                   NBU_UNIQUE | NBU_NOTIFY,
  81.                                   COF_SHOW_HIDE,
  82.                                   0,
  83.                                   NULL,
  84.                                   0
  85. };
  86.  
  87. struct Library *CxBase;
  88. CxObj *broker;
  89.  
  90. #define POPKEY_EVENT 4711
  91.  
  92.  
  93. /* MainWindow stuff */
  94.  
  95. struct NewMenu MainWindowNewMenus[12];
  96. struct Menu *MainWindowMenus;
  97.  
  98. struct Window *MainWindow;
  99. struct Gadget *glist;
  100. struct Gadget *listviewgad;
  101. APTR vi;
  102.  
  103. ULONG MainWindowMinWidth;
  104. ULONG MainWindowMinHeight;
  105. ULONG InnerHeight;
  106. ULONG InnerWidth;
  107. ULONG ListViewHeight;
  108. ULONG XOff,YOff;
  109.  
  110. struct NewGadget gadgets[1];
  111.  
  112. /* Config stuff */
  113.  
  114. struct Window *CfgWindow;
  115. struct AppWindow *appwindow;
  116. struct Gadget *cfgglist;
  117. struct TextFont *textfont;
  118. struct FileInfoBlock *cfgfib;
  119. ULONG CfgWindowMinHeight,CfgWindowMinWidth;
  120. Class *altclass;
  121. APTR getfileimg;
  122.  
  123. LONG cfglastitem;
  124. struct MyNode *cfglastnode;
  125.  
  126. /* Raw */
  127.  
  128. #define ESC      69
  129. #define TAB      66
  130. #define ENTER    67
  131. #define RETURN   68
  132.  
  133. #define NUMPAD_1  0x1d
  134. #define NUMPAD_7  0x3d
  135. #define NUMPAD_2  0x1e
  136. #define NUMPAD_8  0x3e
  137. #define NUMPAD_3  0x1f
  138. #define NUMPAD_9  0x3f
  139.  
  140. #define QUAL_SHIFT (IEQUALIFIER_RSHIFT|IEQUALIFIER_LSHIFT)
  141.  
  142.  
  143. /* WindowPtr */
  144.  
  145. struct Window *windowptr;
  146. struct Process *myproc;
  147.  
  148.  
  149. /* PubScreen */
  150.  
  151. UBYTE *PubScreenName;
  152. struct Screen *PubScreen;
  153.  
  154.  
  155. /* Libraries */
  156.  
  157. extern struct ExecBase *SysBase;
  158. extern struct IntuitionBase *IntuitionBase;
  159. extern struct Library *GadToolsBase;
  160. extern struct Library *DOSBase;
  161. struct Library *KeymapBase;
  162.  
  163. /* Config */
  164.  
  165. UBYTE cfg_Settings[100]="PROGDIR:CommandList.prefs";
  166.  
  167. ULONG cfg_InnerWidth=100;
  168. ULONG cfg_Lines=10;
  169. ULONG cfg_CfgInnerWidth=100;
  170. ULONG cfg_CfgLines=5;
  171. UBYTE cfg_Popkey[50]="alt tab";
  172. BOOL cfg_Popup=FALSE;
  173. LONG lastitem;
  174.  
  175. struct List CommandList;
  176. ULONG maxlist;
  177.  
  178. struct MyNode
  179. {
  180.    struct Node Node;
  181.    UBYTE Type;
  182.    ULONG Stack;
  183.    UBYTE Name[40];
  184.    UBYTE Hotkey[40];
  185.    UBYTE Command[200];
  186.    CxObj *cx;
  187. };
  188.  
  189.  
  190. /* CLI arguments */
  191.  
  192. #define CX_POPUP    0
  193. #define CX_POPKEY   1
  194. #define CX_PRIORITY 2
  195. #define SETTINGS    3
  196.  
  197. UBYTE *argstr="CX_POPUP/S,CX_POPKEY/K,CX_PRIORITY/K/N,SETTINGS/K";
  198. ULONG argarray[4]={NULL,NULL,NULL,NULL};
  199.  
  200. struct RDArgs *rdargs;
  201.  
  202.  
  203. /* Workbench args */
  204.  
  205. void _waitwbmsg(void);
  206. routine_that_is_never_called() { _waitwbmsg(); }
  207. extern struct WBStartup *_WBMsg;
  208.  
  209. #define WORKBENCH 1
  210. #define CLI 2
  211.  
  212. ULONG wbapps;
  213. struct MsgPort *WBReplyPort;
  214. struct MsgPort *WBAppPort;
  215. struct AddMenuItem *appmenuitem;
  216.  
  217. ULONG cxsigflag,wbsigflag,wbappsigflag;
  218.  
  219. /* Requester */
  220.  
  221. struct EasyStruct es = { sizeof(struct EasyStruct),
  222.                          0,
  223.                          "",
  224.                          "",
  225.                          ""  };
  226.  
  227. BOOL OpenAsl(UBYTE *file,UBYTE *title,BOOL save);
  228. UBYTE asl_buf[300];
  229.  
  230. /* String EditHook */
  231.  
  232. #define IEQUALIFIER_SHIFT     (IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT)
  233.  
  234. __asm __geta4 ULONG StrEditHookEntry (register __a0 struct Hook *hook,register __a2 struct SGWork *sgw,register __a1 ULONG *msg)
  235. {
  236.    int qual,rawcode;
  237.  
  238.    if (msg[0] == SGH_KEY)
  239.    {
  240.       rawcode = sgw->IEvent->ie_Code;
  241.       qual = sgw->IEvent->ie_Qualifier;
  242.       if (sgw->EditOp == EO_INSERTCHAR   || sgw->EditOp == EO_REPLACECHAR  || sgw->EditOp == EO_BADFORMAT    ||
  243.          (sgw->EditOp == EO_NOOP && sgw->Actions == (SGA_USE|SGA_BEEP) && sgw->NumChars == (sgw->StringInfo->MaxChars - 1)))
  244.       {
  245.          if ((qual & IEQUALIFIER_RCOMMAND) || sgw->Code == 27)
  246.          {
  247.             sgw->Actions &= ~(SGA_USE|SGA_BEEP|SGA_REDISPLAY);
  248.             sgw->IEvent->ie_Qualifier &= ~IEQUALIFIER_RCOMMAND;
  249.  
  250.             if (!(qual & IEQUALIFIER_REPEAT))
  251.             {
  252.                sgw->Actions |= SGA_REUSE|SGA_END;
  253.                /* sgw->Code = KEYB_SHORTCUT; */
  254.             }
  255.          }
  256.       }
  257.       return (TRUE);
  258.    }
  259.    return (FALSE);
  260. }
  261.  
  262. struct Hook stredithook = { { NULL }, StrEditHookEntry, NULL, NULL };
  263.  
  264. /* Protos */
  265.  
  266. void UnLockWindow(struct Window *win);
  267. BOOL LockWindow(struct Window *win);
  268. void Config(void);
  269. void Popup(void);
  270. void CleanUpCfg(void);
  271. BOOL MayExit(void);
  272. void HandleCx(void);
  273. BOOL FakePress(struct Gadget *gad,struct Window *win,UBYTE rawcode);
  274. void CreateHotkeys(void);
  275. void RemoveHotkeys(void);
  276. BOOL LaunchCommand(struct MyNode *mynode);
  277.  
  278. /* Clean up basic stuff */
  279.  
  280. void CleanUp(int err)
  281. {
  282.    struct MyNode *mynode;
  283.    struct AppMessage *appmsg;
  284.  
  285.    if(KeymapBase)
  286.       CloseLibrary(KeymapBase);
  287.  
  288.    if(WBReplyPort)
  289.       DeleteMsgPort(WBReplyPort);
  290.  
  291.    if(appmenuitem)
  292.       RemoveAppMenuItem(appmenuitem);
  293.  
  294.    if(WBAppPort)
  295.    {
  296.       while(appmsg=(struct AppMessage *)GetMsg(WBAppPort))
  297.          ReplyMsg((struct Message *)appmsg);
  298.  
  299.       DeleteMsgPort(WBAppPort);
  300.    }
  301.  
  302.    if(broker)
  303.       DeleteCxObjAll(broker);
  304.  
  305.    if(newbroker.nb_Port)
  306.       DeleteMsgPort(newbroker.nb_Port);
  307.  
  308.    if(CxBase)
  309.       CloseLibrary(CxBase);
  310.  
  311.    if(catalog)
  312.       CloseCatalog(catalog);
  313.  
  314.    if(locale)
  315.       CloseLocale(locale);
  316.  
  317.    if(LocaleBase)
  318.       CloseLibrary(LocaleBase);
  319.  
  320.    if(rdargs)
  321.       FreeArgs(rdargs);
  322.  
  323.    while(mynode=(struct MyNode *)RemHead(&CommandList))
  324.       FreeMem(mynode,sizeof(struct MyNode));
  325.  
  326.    _exit(err);
  327. }
  328.  
  329. /* Clean up main window */
  330.  
  331. void CleanUpMain(void)
  332. {
  333.    myproc->pr_WindowPtr=windowptr;
  334.  
  335.    if(textfont) CloseFont(textfont);
  336.  
  337.    if(MainWindowMenus)
  338.    {
  339.         ClearMenuStrip(MainWindow);
  340.         FreeMenus(MainWindowMenus);
  341.    }
  342.  
  343.    if(MainWindow)
  344.    {
  345.       if(MainWindow->FirstRequest)
  346.          UnLockWindow(MainWindow);
  347.  
  348.       CloseWindow(MainWindow);
  349.    }
  350.  
  351.    if(glist)      FreeGadgets(glist);
  352.    if(vi)         FreeVisualInfo(vi);
  353.    if(PubScreen)  UnlockPubScreen(NULL,PubScreen);
  354.  
  355.    textfont=NULL;
  356.    MainWindowMenus=NULL;
  357.    PubScreen=NULL;
  358.    MainWindow=NULL;
  359.    glist=NULL;
  360.    vi=NULL;
  361. }
  362.  
  363.  
  364. /* Load/save configuration */
  365.  
  366. void LoadConfig(UBYTE *file)
  367. {
  368.    BPTR fh;
  369.    UBYTE buf[200],buf2[250],buf3[250];
  370.    struct MyNode *mynode;
  371.    ULONG c;
  372.  
  373.    maxlist=0;
  374.  
  375.    if(!(fh=Open(file,MODE_OLDFILE)))
  376.    {
  377.       es.es_Title=getString(REQ_ERRTITLE_STR);
  378.       es.es_TextFormat=getString(ERR_READ_SETTINGS_STR);
  379.       es.es_GadgetFormat=getString(REQ_PROCEED_STR);
  380.  
  381.       if(MainWindow)
  382.          LockWindow(MainWindow);
  383.  
  384.       EasyRequest(NULL,&es,NULL,file);
  385.  
  386.       if(MainWindow)
  387.          UnLockWindow(MainWindow);
  388.  
  389.       return;
  390.    }
  391.  
  392.    while(FGets(fh,buf,199))
  393.    {
  394.       if(buf[0]!=0)
  395.          buf[strlen(buf)-1]=0;
  396.  
  397.       if(strcmp(buf,"END")==0)
  398.          break;
  399.  
  400.       if(strncmp(buf,"WIDTH",5)==0)
  401.          cfg_InnerWidth=atoi(&buf[6]);
  402.  
  403.       if(strncmp(buf,"LINES",5)==0)
  404.          cfg_Lines=atoi(&buf[6]);
  405.  
  406.       if(strncmp(buf,"CFGWIDTH",8)==0)
  407.          cfg_CfgInnerWidth=atoi(&buf[9]);
  408.  
  409.       if(strncmp(buf,"CFGLINES",8)==0)
  410.          cfg_CfgLines=atoi(&buf[9]);
  411.    }
  412.  
  413.    while(FGets(fh,buf,199))
  414.    {
  415.       FGets(fh,buf2,249);
  416.       buf3[0]=0;
  417.  
  418.       if(buf2[0]==':')
  419.       {
  420.          strcpy(buf3,&buf2[1]);
  421.          FGets(fh,buf2,249);
  422.       }
  423.  
  424.       if(buf[0]!=0)
  425.          buf[strlen(buf)-1]=0;
  426.  
  427.       if(buf2[0]!=0)
  428.          buf2[strlen(buf2)-1]=0;
  429.  
  430.       if(buf3[0]!=0)
  431.          buf3[strlen(buf3)-1]=0;
  432.  
  433.       if(!(mynode=AllocMem(sizeof(struct MyNode),MEMF_CLEAR)))
  434.          CleanUpMain();
  435.  
  436.       if(strncmp(buf2,"WB:",3)==0)
  437.       {
  438.          mynode->Type=WORKBENCH;
  439.          c=3;
  440.          mynode->Stack=4000;
  441.       }
  442.       else
  443.       {
  444.          mynode->Type=CLI;
  445.  
  446.          for(c=0;c<strlen(buf2);c++)
  447.             if(buf2[c]==':') break;
  448.  
  449.          buf2[c]=0;
  450.          mynode->Stack=atoi(buf2);
  451.  
  452.          if(mynode->Stack==0)
  453.             mynode->Stack=4000;
  454.  
  455.          c++;
  456.       }
  457.  
  458.       strcpy(mynode->Name,buf);
  459.       strcpy(mynode->Command,&buf2[c]);
  460.       strcpy(mynode->Hotkey,buf3);
  461.       mynode->Node.ln_Name=mynode->Name;
  462.  
  463.       AddTail(&CommandList,(struct Node *)mynode);
  464.       maxlist++;
  465.    }
  466.    Close(fh);
  467. }
  468.  
  469. void SaveConfig(UBYTE *file)
  470. {
  471.    BPTR fh;
  472.    struct MyNode *mynode;
  473.    ULONG c;
  474.  
  475.    if(!(fh=Open(file,MODE_NEWFILE)))
  476.    {
  477.       es.es_Title=getString(REQ_ERRTITLE_STR);
  478.       es.es_TextFormat=getString(ERR_SAVE_SETTINGS_STR);
  479.       es.es_GadgetFormat=getString(REQ_PROCEED_STR);
  480.  
  481.       if(MainWindow)
  482.          LockWindow(MainWindow);
  483.  
  484.       EasyRequest(NULL,&es,NULL,file);
  485.  
  486.       if(MainWindow)
  487.          UnLockWindow(MainWindow);
  488.  
  489.       return;
  490.    }
  491.  
  492.    FPrintf(fh,"WIDTH %lu\n",cfg_InnerWidth);
  493.    FPrintf(fh,"LINES %lu\n",cfg_Lines);
  494.    FPrintf(fh,"CFGWIDTH %lu\n",cfg_CfgInnerWidth);
  495.    FPrintf(fh,"CFGLINES %lu\n",cfg_CfgLines);
  496.    FPuts(fh,"END\n");
  497.  
  498.    mynode=(struct MyNode *)CommandList.lh_Head;
  499.  
  500.    for(c=0;c<maxlist;c++)
  501.    {
  502.       FPrintf(fh,"%s\n",mynode->Name);
  503.  
  504.       if(mynode->Hotkey[0])
  505.          FPrintf(fh,":%s\n",mynode->Hotkey);
  506.  
  507.       if(mynode->Type==WORKBENCH)
  508.          FPrintf(fh,"WB:%s\n",mynode->Command);
  509.  
  510.       else
  511.          FPrintf(fh,"%lu:%s\n",mynode->Stack,mynode->Command);
  512.  
  513.       mynode=(struct MyNode *)mynode->Node.ln_Succ;
  514.    }
  515.  
  516.    Close(fh);
  517. }
  518.  
  519. /* Commodity handling */
  520.  
  521. void Appear(void)
  522. {
  523.    if(CfgWindow)
  524.    {
  525.       ScreenToFront(PubScreen);
  526.       WindowToFront(CfgWindow);
  527.       ActivateWindow(CfgWindow);
  528.    }
  529.    else if(MainWindow)
  530.    {
  531.       ScreenToFront(PubScreen);
  532.       WindowToFront(MainWindow);
  533.       ActivateWindow(MainWindow);
  534.    }
  535.    else
  536.    {
  537.       Popup();
  538.    }
  539. }
  540.  
  541. void HandleCx(void)
  542. {
  543.    ULONG msgid,msgtype,c;
  544.    struct MyNode *mynode;
  545.    CxMsg *msg;
  546.  
  547.    while(msg = (CxMsg *)GetMsg(newbroker.nb_Port))
  548.    {
  549.       msgid = CxMsgID(msg);
  550.       msgtype = CxMsgType(msg);
  551.       ReplyMsg((struct Message *)msg);
  552.  
  553.       switch(msgtype)
  554.       {
  555.          case CXM_IEVENT:  if(msgid == POPKEY_EVENT)
  556.                            {
  557.                               Appear();
  558.                            }
  559.                            else if(msgid>0 && msgid<=maxlist)
  560.                            {
  561.                               msgid--;
  562.  
  563.                               mynode=CommandList.lh_Head;
  564.  
  565.                               for(c=0;c<msgid;c++)
  566.                                  mynode=mynode->Node.ln_Succ;
  567.  
  568.                               LaunchCommand(mynode);
  569.                            }
  570.                            break;
  571.  
  572.          case CXM_COMMAND: switch(msgid)
  573.                            {
  574.                               case CXCMD_UNIQUE:
  575.                               case CXCMD_APPEAR:    Appear();
  576.                                                     break;
  577.                               case CXCMD_DISAPPEAR: if(CfgWindow)  CleanUpCfg();
  578.                                                     if(MainWindow) CleanUpMain();
  579.                                                     return;
  580.                               case CXCMD_DISABLE:   ActivateCxObj(broker,0);
  581.                                                     break;
  582.                               case CXCMD_ENABLE:    ActivateCxObj(broker,1);
  583.                                                     break;
  584.                               case CXCMD_KILL:      if(MayExit())
  585.                                                     {
  586.                                                        if(CfgWindow)  CleanUpCfg();
  587.                                                        if(MainWindow) CleanUpMain();
  588.                                                        CleanUp(0);
  589.                                                     }
  590.                                                     break;
  591.                            }
  592.       }
  593.    }
  594. }
  595.  
  596. /***** Launching of CLI and Workbench commands ******/
  597.  
  598. BOOL LaunchCommand(struct MyNode *mynode)
  599. {
  600.    UBYTE *screenname;
  601.    struct Screen *s;
  602.    ULONG lock;
  603.    struct PubScreenNode *psnode;
  604.  
  605.    lock = LockIBase(0);
  606.    s=IntuitionBase->FirstScreen;
  607.    UnlockIBase(lock);
  608.  
  609.    screenname=NULL;
  610.    if(s->Flags & WBENCHSCREEN)
  611.    {
  612.       screenname="Workbench";
  613.    }
  614.    else
  615.    {
  616.       if(s->Flags & PUBLICSCREEN)
  617.       {
  618.          /* s is a public screen so find its name */
  619.  
  620.          psnode=(struct PubScreenNode *)LockPubScreenList();
  621.  
  622.          while ((psnode) && !(screenname))
  623.          {
  624.             if((psnode->psn_Flags != PSNF_PRIVATE) && (psnode->psn_Screen == s))
  625.             {
  626.                /* found it */
  627.                screenname = psnode->psn_Node.ln_Name;
  628.             }
  629.             else
  630.             {
  631.                /* check next one */
  632.                psnode = (struct PubScreenNode *)psnode->psn_Node.ln_Succ;
  633.             }
  634.          }
  635.          UnlockPubScreenList();
  636.       }
  637.    }
  638.  
  639.    if(mynode->Type==WORKBENCH)
  640.    {
  641.       struct WBStartup *wbst;
  642.       BPTR segment,dirlock;
  643.       struct MsgPort *procport;
  644.       struct WBArg *wba;
  645.       char *app_name,*what;
  646.       UBYTE name[200];
  647.       struct DiskObject *dobj;
  648.       ULONG stack;
  649.       BYTE pri;
  650.  
  651.       if(!(dobj=GetDiskObject(mynode->Command)))
  652.       {
  653.          es.es_Title=getString(REQ_ERRTITLE_STR);
  654.          es.es_TextFormat=getString(ERR_LAUNCH_NOICON_STR);
  655.          es.es_GadgetFormat=getString(REQ_PROCEED_STR);
  656.          LockWindow(MainWindow);
  657.          EasyRequest(NULL,&es,NULL,mynode->Command);
  658.          UnLockWindow(MainWindow);
  659.          return(FALSE);
  660.       }
  661.  
  662.       stack=0;
  663.       pri=0;
  664.  
  665.       if(dobj->do_Type==WBTOOL)
  666.       {
  667.          stack=dobj->do_StackSize;
  668.  
  669.          if(stack==0)
  670.             stack=4096;
  671.  
  672.          if(what=FindToolType(dobj->do_ToolTypes,"TOOLPRI"))
  673.             pri=atoi(what);
  674.       }
  675.       FreeDiskObject(dobj);
  676.  
  677.       strcpy(name,mynode->Command);
  678.       *PathPart(name) = '\0'; /* get directory name: V36 and up only! */
  679.  
  680.       if(!(dirlock=Lock(name,SHARED_LOCK)))
  681.       {
  682.          es.es_Title=getString(REQ_ERRTITLE_STR);
  683.          es.es_TextFormat=getString(ERR_LAUNCH_NODIR_STR);
  684.          es.es_GadgetFormat=getString(REQ_PROCEED_STR);
  685.          LockWindow(MainWindow);
  686.          EasyRequest(NULL,&es,NULL,name);
  687.          UnLockWindow(MainWindow);
  688.          return(FALSE);
  689.       }
  690.  
  691.       if(!(wbst=( struct WBStartup * )AllocMem( sizeof( struct WBStartup ), MEMF_CLEAR)))
  692.       {
  693.          DisplayBeep(NULL);
  694.          UnLock(dirlock);
  695.          return(FALSE);
  696.       }
  697.  
  698.       if(!(segment=LoadSeg(mynode->Command)))
  699.       {
  700.          UnLock(dirlock);
  701.          FreeMem(wbst,sizeof( struct WBStartup));
  702.          es.es_Title=getString(REQ_ERRTITLE_STR);
  703.          es.es_TextFormat=getString(ERR_LAUNCH_NOTFOUND_STR);
  704.          es.es_GadgetFormat=getString(REQ_PROCEED_STR);
  705.          LockWindow(MainWindow);
  706.          EasyRequest(NULL,&es,NULL,mynode->Command);
  707.          UnLockWindow(MainWindow);
  708.          return(FALSE);
  709.       }
  710.  
  711.       if(!(wba=(struct WBArg *)AllocMem(sizeof(struct WBArg),MEMF_CLEAR )))
  712.       {
  713.          UnLock(dirlock);
  714.          UnLoadSeg(segment );
  715.          FreeMem(wbst,sizeof(struct WBStartup));
  716.          DisplayBeep(NULL);
  717.          return(FALSE);
  718.       }
  719.  
  720.       app_name=FilePart(mynode->Command);  /* V36 and above only! */
  721.  
  722.       Forbid();
  723.       if(!(procport=(struct MsgPort *)CreateProc(app_name,pri,segment,stack)))
  724.       {
  725.          Permit();
  726.          UnLoadSeg(segment);
  727.          FreeMem( wbst, sizeof( struct WBStartup ) );
  728.          UnLock(dirlock);
  729.          es.es_Title=getString(REQ_ERRTITLE_STR);
  730.          es.es_TextFormat=getString(ERR_LAUNCH_CREATEPROC_STR);
  731.          es.es_GadgetFormat=getString(REQ_PROCEED_STR);
  732.          LockWindow(MainWindow);
  733.          EasyRequest(NULL,&es,NULL,NULL);
  734.          UnLockWindow(MainWindow);
  735.          return(FALSE);
  736.       }
  737.  
  738.       ((struct Process *)procport->mp_SigTask)->pr_HomeDir=dirlock;
  739.       ((struct Process *)procport->mp_SigTask)->pr_WindowPtr=NULL;
  740.       ((struct Process *)procport->mp_SigTask)->pr_ConsoleTask=NULL;
  741.       Permit();
  742.  
  743.       wba -> wa_Lock = dirlock;
  744.       wba -> wa_Name = app_name;   /* application name (same as in CreateProc()) */
  745.  
  746.       wbst -> sm_Message.mn_ReplyPort = WBReplyPort;  /* main() must supply a MsgPort! */
  747.       wbst -> sm_Message.mn_Length = sizeof( struct WBStartup );
  748.       wbst -> sm_Process = procport;
  749.       wbst -> sm_Segment = segment;
  750.       wbst -> sm_NumArgs = 1;
  751.       wbst -> sm_ArgList = wba;
  752.       wbst -> sm_ToolWindow = NULL;
  753.  
  754.       PutMsg(procport,(struct Message * )wbst);
  755.       wbapps++;
  756.    }
  757.    else
  758.    {
  759.       ULONG c,d;
  760.       UBYTE conspec[200];
  761.       UBYTE command[512];
  762.       UBYTE *cmd;
  763.       BPTR winfh;
  764.  
  765.       cmd=mynode->Command;
  766.  
  767.       d=0;
  768.       for(c=0;c<strlen(cmd);c++)
  769.       {
  770.          if(cmd[c]=='%' && (cmd[c+1]|32)=='s')
  771.          {
  772.             strcpy(&command[d],screenname);
  773.             d+=strlen(screenname);
  774.             c++;
  775.          }
  776.          else command[d++]=cmd[c];
  777.       }
  778.       command[d]=0;
  779.  
  780.       strcpy(conspec,"CON:0/25//150/");
  781.       strcat(conspec,getString(CON_TITLE_STR));
  782.       strcat(conspec,"/AUTO/WAIT/SCREEN");
  783.       strcat(conspec,screenname);
  784.  
  785.       if(winfh=Open(conspec,MODE_READWRITE))
  786.       {
  787.          SystemTags(command,SYS_Input,winfh,
  788.                             SYS_Output,NULL,
  789.                             SYS_Asynch,TRUE,
  790.                             SYS_UserShell, TRUE,
  791.                             NP_StackSize,mynode->Stack,
  792.                             TAG_END);
  793.       }
  794.    }
  795.    return(TRUE);
  796. }
  797.  
  798. void ProcessWorkbench(void)
  799. {
  800.    struct WBStartup *wbst;
  801.  
  802.    while(wbst=(struct WBStartup *)GetMsg(WBReplyPort))
  803.    {
  804.       wbapps--;
  805.  
  806.       if(wbst->sm_Segment)
  807.          UnLoadSeg(wbst->sm_Segment);
  808.  
  809.       if(wbst->sm_ArgList)
  810.       {
  811.          if(wbst->sm_ArgList->wa_Lock)
  812.             UnLock(wbst->sm_ArgList->wa_Lock);
  813.       }
  814.       FreeMem(wbst->sm_ArgList,sizeof(struct WBArg));
  815.       FreeMem(wbst,sizeof(struct WBStartup));
  816.    }
  817. }
  818.  
  819. void RemoveHotkeys(void)
  820. {
  821.    struct MyNode *mynode;
  822.    int c;
  823.  
  824.    mynode=(struct MyNode *)CommandList.lh_Head;
  825.  
  826.    for(c=0;c<maxlist;c++)
  827.    {
  828.       if(mynode->cx)
  829.       {
  830.          DeleteCxObj(mynode->cx);
  831.          mynode->cx=NULL;
  832.       }
  833.       mynode=(struct MyNode *)mynode->Node.ln_Succ;
  834.    }
  835. }
  836.  
  837. void CreateHotkeys(void)
  838. {
  839.    struct MyNode *mynode;
  840.    int c;
  841.  
  842.    mynode=(struct MyNode *)CommandList.lh_Head;
  843.  
  844.    for(c=0;c<maxlist;c++)
  845.    {
  846.       if(mynode->Hotkey[0])
  847.       {
  848.          if(!(mynode->cx = HotKey(mynode->Hotkey,newbroker.nb_Port,c+1)))
  849.          {
  850.             es.es_Title=getString(REQ_ERRTITLE_STR);
  851.             es.es_TextFormat=getString(ERR_INVALID_ITEM_HOTKEY_STR);
  852.             es.es_GadgetFormat=getString(REQ_PROCEED_STR);
  853.  
  854.             if(MainWindow)
  855.                EasyRequest(MainWindow,&es,NULL,mynode->Hotkey,mynode->Name);
  856.             else
  857.                EasyRequest(NULL,&es,NULL,mynode->Hotkey,mynode->Name);
  858.          }
  859.          else
  860.          {
  861.             AttachCxObj(broker,mynode->cx);
  862.          }
  863.       }
  864.       mynode=(struct MyNode *)mynode->Node.ln_Succ;
  865.    }
  866. }
  867.  
  868. BOOL MayExit(void)
  869. {
  870.    if(wbapps == 0)
  871.       return(TRUE);
  872.  
  873.    es.es_Title=getString(REQ_ERRTITLE_STR);
  874.    es.es_TextFormat=getString(ERR_LAUNCH_STILLWORKBENCH_STR);
  875.    es.es_GadgetFormat=getString(REQ_PROCEED_STR);
  876.  
  877.    if(CfgWindow)
  878.       LockWindow(CfgWindow);
  879.  
  880.    else if(MainWindow)
  881.       LockWindow(MainWindow);
  882.  
  883.    EasyRequest(NULL,&es,NULL,wbapps);
  884.  
  885.    if(CfgWindow)
  886.       UnLockWindow(CfgWindow);
  887.  
  888.    else if(MainWindow)
  889.       UnLockWindow(MainWindow);
  890.  
  891.    return(FALSE);
  892. }
  893.  
  894.  
  895. /***** Main Window *****/
  896.  
  897. int ListViewTop(struct Gadget *gadget, struct Window *window)
  898. {
  899.    ULONG top;
  900.  
  901.    if (GadToolsBase->lib_Version < 39)
  902.       top = *(UWORD *)(((char *)gadget) + sizeof(struct Gadget) + 4);
  903.    else
  904.       GT_GetGadgetAttrs(gadget, window, NULL, GTLV_Top, &top, TAG_DONE);
  905.  
  906.    return (top);
  907. }
  908.  
  909. void MakeVisible(ULONG vis,ULONG lines,struct Gadget *gadget, struct Window *window)
  910. {
  911.    ULONG top;
  912.  
  913.    if (GadToolsBase->lib_Version < 39)
  914.    {
  915.       top=ListViewTop(gadget,window);
  916.  
  917.       if(vis < top)
  918.       {
  919.          while(vis < top)
  920.             top--;
  921.       }
  922.       else
  923.       {
  924.          while(vis > top+lines-1)
  925.             top++;
  926.       }
  927.  
  928.       GT_SetGadgetAttrs(gadget,window,NULL,GTLV_Top,top,TAG_END);
  929.    }
  930.    else
  931.    {
  932.       GT_SetGadgetAttrs(gadget,window,NULL,GTLV_MakeVisible,vis,TAG_END);
  933.    }
  934. }
  935.  
  936. void DrawMainGUI(void)
  937. {
  938.    struct Gadget *lastgad=NULL;
  939.  
  940.    InnerHeight=MainWindow->Height-MainWindow->BorderTop-MainWindow->BorderBottom;
  941.    InnerWidth=MainWindow->Width-MainWindow->BorderLeft-MainWindow->BorderRight;
  942.  
  943.    XOff=MainWindow->BorderLeft;
  944.    YOff=MainWindow->BorderTop;
  945.  
  946.    ListViewHeight=InnerHeight-2;
  947.  
  948.    if(GadToolsBase->lib_Version < 39)
  949.       cfg_Lines=(ListViewHeight-8)/PubScreen->Font->ta_YSize-1;
  950.  
  951.    else
  952.       cfg_Lines=(ListViewHeight-4)/PubScreen->Font->ta_YSize;
  953.  
  954.    cfg_InnerWidth=MainWindow->Width-MainWindow->BorderLeft-MainWindow->BorderRight;
  955.  
  956.    glist=NULL;
  957.  
  958.    lastgad=(struct Gadget *)CreateContext(&glist);
  959.  
  960.    gadgets[0].ng_LeftEdge=XOff+2;
  961.    gadgets[0].ng_TopEdge=YOff+1;
  962.    gadgets[0].ng_Height=ListViewHeight;
  963.    gadgets[0].ng_Width=InnerWidth-4;
  964.    gadgets[0].ng_TextAttr=PubScreen->Font;
  965.    gadgets[0].ng_VisualInfo=vi;
  966.  
  967.    lastgad = CreateGadget(LISTVIEW_KIND,lastgad,&gadgets[0],GTLV_ShowSelected,NULL,
  968.                                                             GTLV_Labels,&CommandList,
  969.                                                             TAG_END);
  970.  
  971.    listviewgad=lastgad;
  972.  
  973.    AddGList(MainWindow,glist,-1,-1,NULL);
  974.    RefreshGList(glist,MainWindow,NULL,-1);
  975.    GT_RefreshWindow(MainWindow,NULL);
  976.  
  977.    if(maxlist!=0)
  978.    {
  979.       GT_SetGadgetAttrs(listviewgad,MainWindow,NULL,GTLV_Selected,lastitem,TAG_END);
  980.       MakeVisible(lastitem,cfg_Lines,listviewgad,MainWindow);
  981.    }
  982. }
  983.  
  984. void Popup(void)
  985. {
  986.    struct Screen *s;
  987.    ULONG lock,c,sigs;
  988.    struct PubScreenNode *psnode;
  989.    struct IntuiMessage *IntuiMessage;
  990.    ULONG class,InnerHeight,xpos,ypos,code,secs,micros,oldsecs,oldmicros,qualifier,num;
  991.    struct MyNode *mynode;
  992.    struct MenuItem *menuitem;
  993.    struct AppMessage *appmsg;
  994.    BOOL action;
  995.  
  996.    windowptr=myproc->pr_WindowPtr;
  997.  
  998.    /* Choose a public screen to open our window */
  999.    lock = LockIBase(0);
  1000.    s=IntuitionBase->FirstScreen;
  1001.    UnlockIBase(lock);
  1002.  
  1003.    PubScreenName = NULL;
  1004.    if ( s->Flags & WBENCHSCREEN )
  1005.    {
  1006.       PubScreenName = "Workbench" ;
  1007.    }
  1008.    else
  1009.    {
  1010.       if ( s->Flags & PUBLICSCREEN )
  1011.       {
  1012.          /* s is a public screen so find its name */
  1013.  
  1014.          psnode=(struct PubScreenNode *)LockPubScreenList();
  1015.  
  1016.          while ((psnode) && !(PubScreenName))
  1017.          {
  1018.             if ((psnode->psn_Flags != PSNF_PRIVATE) && (psnode->psn_Screen == s))
  1019.             {
  1020.                /* found it */
  1021.                PubScreenName = psnode->psn_Node.ln_Name;
  1022.             }
  1023.             else
  1024.             {
  1025.                /* check next one */
  1026.                psnode = (struct PubScreenNode *)psnode->psn_Node.ln_Succ;
  1027.             }
  1028.          }
  1029.          UnlockPubScreenList();
  1030.       }
  1031.    }
  1032.  
  1033.    if(!(PubScreen=LockPubScreen(PubScreenName)))
  1034.       return;
  1035.  
  1036.    ScreenToFront(PubScreen);
  1037.  
  1038.    if(!(textfont=OpenFont(PubScreen->Font)))
  1039.    {
  1040.       DisplayBeep(NULL);
  1041.       CleanUpMain();
  1042.       return;
  1043.    }
  1044.  
  1045.    if(!(vi=(APTR)GetVisualInfo(PubScreen,TAG_END)))
  1046.    {
  1047.       DisplayBeep(NULL);
  1048.       CleanUpMain();
  1049.       return;
  1050.    }
  1051.  
  1052.    if(GadToolsBase->lib_Version < 39)
  1053.       InnerHeight=(cfg_Lines+1)*PubScreen->Font->ta_YSize+8+2;
  1054.  
  1055.    else
  1056.       InnerHeight=cfg_Lines*PubScreen->Font->ta_YSize+4+2;
  1057.  
  1058.    ypos=PubScreen->MouseY-PubScreen->WBorTop-PubScreen->Font->ta_YSize-1-1-2-PubScreen->Font->ta_YSize/2;
  1059.  
  1060.    if(ypos<0)
  1061.       ypos=0;
  1062.  
  1063.    xpos=PubScreen->MouseX-20;
  1064.  
  1065.    if(xpos<0)
  1066.       xpos=0;
  1067.  
  1068.    if(!(MainWindow=OpenWindowTags(NULL,WA_Left,               xpos,
  1069.                                        WA_Top,                ypos,
  1070.                                        WA_InnerWidth,         cfg_InnerWidth,
  1071.                                        WA_InnerHeight,        InnerHeight,
  1072.                                        WA_MinWidth,           -1,
  1073.                                        WA_MinHeight,          -1,
  1074.                                        WA_MaxWidth,           -1,
  1075.                                        WA_MaxHeight,          -1,
  1076.                                        WA_AutoAdjust,         TRUE,
  1077.                                        WA_Flags,              WFLG_SIZEGADGET|WFLG_SIZEBBOTTOM|WFLG_ACTIVATE|WFLG_CLOSEGADGET|WFLG_DEPTHGADGET|WFLG_DRAGBAR|WFLG_NEWLOOKMENUS,
  1078.                                        WA_IDCMP,              IDCMP_NEWSIZE|IDCMP_CLOSEWINDOW|LISTVIEWIDCMP|IDCMP_RAWKEY|IDCMP_MENUPICK,
  1079.                                        WA_Title,              "CommandList "VERSION" © 1994 Johan Billing",
  1080.                                        WA_PubScreenName,      PubScreenName,
  1081.                                        WA_PubScreenFallBack,  TRUE,
  1082.                                        TAG_END)))
  1083.    {
  1084.       DisplayBeep(NULL);
  1085.       CleanUpMain();
  1086.       return;
  1087.    }
  1088.  
  1089.    SetFont(MainWindow->RPort,textfont);
  1090.  
  1091.    myproc->pr_WindowPtr=MainWindow;
  1092.  
  1093.    MainWindowMinWidth=100+MainWindow->BorderLeft+MainWindow->BorderRight;
  1094.  
  1095.    if(GadToolsBase->lib_Version < 39)
  1096.       MainWindowMinHeight=(5+1)*PubScreen->Font->ta_YSize+8+2+MainWindow->BorderTop+MainWindow->BorderBottom;
  1097.  
  1098.    else
  1099.       MainWindowMinHeight=5*PubScreen->Font->ta_YSize+4+2+MainWindow->BorderTop+MainWindow->BorderBottom;
  1100.  
  1101.    WindowLimits(MainWindow,MainWindowMinWidth,MainWindowMinHeight,-1,-1);
  1102.  
  1103.    MainWindowNewMenus[0].nm_Type    = NM_TITLE;
  1104.    MainWindowNewMenus[0].nm_Label   = getString(MAIN_MENU_PROJECT_STR);
  1105.  
  1106.    MainWindowNewMenus[1].nm_Type    = NM_ITEM;
  1107.    MainWindowNewMenus[1].nm_Label   = getString(MAIN_MENU_ABOUT_STR);
  1108.    MainWindowNewMenus[1].nm_CommKey = getString(MAIN_MENU_ABOUT_KEY);
  1109.  
  1110.    MainWindowNewMenus[2].nm_Type    = NM_ITEM;
  1111.    MainWindowNewMenus[2].nm_Label   = (STRPTR)NM_BARLABEL;
  1112.  
  1113.    MainWindowNewMenus[3].nm_Type    = NM_ITEM;
  1114.    MainWindowNewMenus[3].nm_Label   = getString(MAIN_MENU_HIDE_STR);
  1115.    MainWindowNewMenus[3].nm_CommKey = getString(MAIN_MENU_HIDE_KEY);
  1116.  
  1117.    MainWindowNewMenus[4].nm_Type    = NM_ITEM;
  1118.    MainWindowNewMenus[4].nm_Label   = getString(MAIN_MENU_QUIT_STR);
  1119.    MainWindowNewMenus[4].nm_CommKey = getString(MAIN_MENU_QUIT_KEY);
  1120.  
  1121.    MainWindowNewMenus[5].nm_Type    = NM_TITLE;
  1122.    MainWindowNewMenus[5].nm_Label   = getString(MAIN_MENU_SETTINGS_STR);
  1123.  
  1124.    MainWindowNewMenus[6].nm_Type    = NM_ITEM;
  1125.    MainWindowNewMenus[6].nm_Label   = getString(MAIN_MENU_EDITCOMMANDS_STR);
  1126.    MainWindowNewMenus[6].nm_CommKey = getString(MAIN_MENU_EDITCOMMANDS_KEY);
  1127.  
  1128.    MainWindowNewMenus[7].nm_Type    = NM_ITEM;
  1129.    MainWindowNewMenus[7].nm_Label   = (STRPTR)NM_BARLABEL;
  1130.  
  1131.    MainWindowNewMenus[8].nm_Type    = NM_ITEM;
  1132.    MainWindowNewMenus[8].nm_Label   = getString(MAIN_MENU_LOADSETTINGS_STR);
  1133.    MainWindowNewMenus[8].nm_CommKey = getString(MAIN_MENU_LOADSETTINGS_KEY);
  1134.  
  1135.    MainWindowNewMenus[9].nm_Type    = NM_ITEM;
  1136.    MainWindowNewMenus[9].nm_Label   = getString(MAIN_MENU_SAVESETTINGS_STR);
  1137.    MainWindowNewMenus[9].nm_CommKey = getString(MAIN_MENU_SAVESETTINGS_KEY);
  1138.  
  1139.    MainWindowNewMenus[10].nm_Type    = NM_ITEM;
  1140.    MainWindowNewMenus[10].nm_Label   = getString(MAIN_MENU_SAVESETTINGSAS_STR);
  1141.    MainWindowNewMenus[10].nm_CommKey = getString(MAIN_MENU_SAVESETTINGSAS_KEY);
  1142.  
  1143.    MainWindowNewMenus[11].nm_Type    = NM_END;
  1144.  
  1145.     if(!(MainWindowMenus=CreateMenus(MainWindowNewMenus,GTMN_FrontPen,0L,TAG_DONE)))
  1146.    {
  1147.       DisplayBeep(NULL);
  1148.       CleanUpMain();
  1149.       return;
  1150.    }
  1151.  
  1152.     LayoutMenus(MainWindowMenus,vi,GTMN_TextAttr,PubScreen->Font,GTMN_NewLookMenus,TRUE,TAG_DONE);
  1153.     SetMenuStrip(MainWindow,MainWindowMenus);
  1154.  
  1155.    DrawMainGUI();
  1156.  
  1157.    oldsecs=0;
  1158.    oldmicros=0;
  1159.  
  1160.    for(;;)
  1161.    {
  1162.       sigs = Wait(1<<MainWindow->UserPort->mp_SigBit | cxsigflag | wbsigflag | SIGBREAKF_CTRL_C | wbappsigflag);
  1163.  
  1164.       while(IntuiMessage=(struct IntuiMessage *)GT_GetIMsg(MainWindow->UserPort))
  1165.       {
  1166.          class=IntuiMessage->Class;
  1167.          code=IntuiMessage->Code;
  1168.          secs=IntuiMessage->Seconds;
  1169.          micros=IntuiMessage->Micros;
  1170.          qualifier=IntuiMessage->Qualifier;
  1171.          GT_ReplyIMsg(IntuiMessage);
  1172.  
  1173.          switch(class)
  1174.          {
  1175.             case IDCMP_CLOSEWINDOW:   CleanUpMain();
  1176.                                       return;
  1177.  
  1178.             case IDCMP_MENUPICK:      num=code;
  1179.                                       while(num!=MENUNULL)
  1180.                                       {
  1181.                                          if(MENUNUM(num)==0)
  1182.                                          {
  1183.                                             switch(ITEMNUM(num))
  1184.                                             {
  1185.                                                case 0: LockWindow(MainWindow);
  1186.                                                        es.es_Title=getString(REQ_ABOUTTITLE_STR);
  1187.                                                        es.es_TextFormat=getString(REQ_ABOUTTEXT_STR);
  1188.                                                        es.es_GadgetFormat=getString(REQ_OK_STR);
  1189.                                                        EasyRequest(NULL,&es,NULL,VERSION,__COMMODORE_DATE__,cfg_Popkey,wbapps);
  1190.                                                        UnLockWindow(MainWindow);
  1191.                                                        break;
  1192.                                                case 2: CleanUpMain();
  1193.                                                        return;
  1194.                                                case 3: if(MayExit())
  1195.                                                        {
  1196.                                                           CleanUpMain();
  1197.                                                           CleanUp(0);
  1198.                                                        }
  1199.                                             }
  1200.                                          }
  1201.                                          if(MENUNUM(num)==1)
  1202.                                          {
  1203.                                             switch(ITEMNUM(num))
  1204.                                             {
  1205.                                                case 0:
  1206.                                                   LockWindow(MainWindow);
  1207.                                                   GT_SetGadgetAttrs(listviewgad,MainWindow,NULL,GTLV_Labels,~0,TAG_END);
  1208.                                                   RemoveHotkeys();
  1209.                                                   Config();
  1210.  
  1211.                                                   if(MainWindow==NULL)
  1212.                                                      return;
  1213.  
  1214.                                                   CreateHotkeys();
  1215.                                                   GT_SetGadgetAttrs(listviewgad,MainWindow,NULL,GTLV_Labels,&CommandList,TAG_END);
  1216.                                                   lastitem=0;
  1217.                                                   GT_SetGadgetAttrs(listviewgad,MainWindow,NULL,GTLV_Selected,lastitem,TAG_END);
  1218.                                                   MakeVisible(lastitem,cfg_Lines,listviewgad,MainWindow);
  1219.                                                   UnLockWindow(MainWindow);
  1220.                                                   break;
  1221.                                                case 2:
  1222.                                                   if(OpenAsl(asl_buf,getString(MAIN_MENU_LOADSETTINGS_STR),FALSE))
  1223.                                                   {
  1224.                                                      struct MyNode *mynode;
  1225.  
  1226.                                                      while(mynode=(struct MyNode *)RemHead(&CommandList))
  1227.                                                         FreeMem(mynode,sizeof(struct MyNode));
  1228.  
  1229.                                                      NewList(&CommandList);
  1230.  
  1231.                                                      GT_SetGadgetAttrs(listviewgad,MainWindow,NULL,GTLV_Labels,~0,TAG_END);
  1232.                                                      RemoveHotkeys();
  1233.                                                      LoadConfig(asl_buf);
  1234.                                                      CreateHotkeys();
  1235.                                                      GT_SetGadgetAttrs(listviewgad,MainWindow,NULL,GTLV_Labels,&CommandList,TAG_END);
  1236.                                                      lastitem=0;
  1237.                                                      GT_SetGadgetAttrs(listviewgad,MainWindow,NULL,GTLV_Selected,lastitem,TAG_END);
  1238.                                                      MakeVisible(lastitem,cfg_Lines,listviewgad,MainWindow);
  1239.                                                   }
  1240.                                                   break;
  1241.                                                case 3:
  1242.                                                   SaveConfig(cfg_Settings);
  1243.                                                   break;
  1244.                                                case 4:
  1245.                                                   if(OpenAsl(asl_buf,getString(MAIN_MENU_SAVESETTINGSAS_STR),TRUE))
  1246.                                                   {
  1247.                                                      GT_SetGadgetAttrs(listviewgad,MainWindow,NULL,GTLV_Labels,~0,TAG_END);
  1248.                                                      SaveConfig(asl_buf);
  1249.                                                      GT_SetGadgetAttrs(listviewgad,MainWindow,NULL,GTLV_Labels,&CommandList,TAG_END);
  1250.                                                      lastitem=0;
  1251.                                                      GT_SetGadgetAttrs(listviewgad,MainWindow,NULL,GTLV_Selected,lastitem,TAG_END);
  1252.                                                      MakeVisible(lastitem,cfg_Lines,listviewgad,MainWindow);
  1253.                                                   }
  1254.                                                   break;
  1255.                                             }
  1256.                                          }
  1257.                                          menuitem=ItemAddress(MainWindowMenus,num);
  1258.                                          num=menuitem->NextSelect;
  1259.                                       }
  1260.  
  1261.                                       break;
  1262.  
  1263.             case IDCMP_RAWKEY:        action=TRUE;
  1264.  
  1265.                                       if((code == CURSORUP && (qualifier & QUAL_SHIFT)) || code == NUMPAD_9)
  1266.                                       {
  1267.                                          if(ListViewTop(listviewgad,MainWindow)==lastitem)
  1268.                                             lastitem-=cfg_Lines-1;
  1269.  
  1270.                                          else
  1271.                                             lastitem=ListViewTop(listviewgad,MainWindow);
  1272.  
  1273.                                          if(lastitem<0)
  1274.                                             lastitem=0;
  1275.                                       }
  1276.                                       else if((code == CURSORUP && (qualifier & IEQUALIFIER_CONTROL)) || code == NUMPAD_7)
  1277.                                       {
  1278.                                          lastitem=0;
  1279.                                       }
  1280.                                       else if(code == CURSORUP || code == NUMPAD_8)
  1281.                                       {
  1282.                                          if(lastitem>0)
  1283.                                             lastitem--;
  1284.                                       }
  1285.                                       else if((code == CURSORDOWN && (qualifier & QUAL_SHIFT)) || code == NUMPAD_3)
  1286.                                       {
  1287.                                          if(ListViewTop(listviewgad,MainWindow)+cfg_Lines-1==lastitem)
  1288.                                             lastitem+=cfg_Lines-1;
  1289.  
  1290.                                          else
  1291.                                            lastitem=ListViewTop(listviewgad,MainWindow)+cfg_Lines-1;
  1292.  
  1293.                                          if(lastitem>=maxlist)
  1294.                                            lastitem=maxlist-1;
  1295.                                       }
  1296.                                       else if((code == CURSORDOWN && (qualifier & IEQUALIFIER_CONTROL)) || code == NUMPAD_1)
  1297.                                       {
  1298.                                          lastitem=maxlist-1;
  1299.                                       }
  1300.                                       else if(code == CURSORDOWN || code == NUMPAD_2)
  1301.                                       {
  1302.                                          if(lastitem<maxlist-1)
  1303.                                             lastitem++;
  1304.                                       }
  1305.                                       else if(code == ESC)
  1306.                                       {
  1307.                                          CleanUpMain();
  1308.                                          return;
  1309.                                       }
  1310.                                       else if(code == ENTER || code == RETURN)
  1311.                                       {
  1312.                                          mynode=CommandList.lh_Head;
  1313.  
  1314.                                          for(c=0;c<lastitem;c++)
  1315.                                             mynode=mynode->Node.ln_Succ;
  1316.  
  1317.                                          if(LaunchCommand(mynode))
  1318.                                          {
  1319.                                            CleanUpMain();
  1320.                                            return;
  1321.                                          }
  1322.                                       }
  1323.                                       else
  1324.                                       {
  1325.                                          action=FALSE;
  1326.                                       }
  1327.  
  1328.                                       if(action)
  1329.                                       {
  1330.                                          GT_SetGadgetAttrs(listviewgad,MainWindow,NULL,GTLV_Selected,lastitem,TAG_END);
  1331.                                          MakeVisible(lastitem,cfg_Lines,listviewgad,MainWindow);
  1332.                                       }
  1333.  
  1334.                                       break;
  1335.  
  1336.             case IDCMP_GADGETUP:      if(code==lastitem)
  1337.                                          if(DoubleClick(oldsecs,oldmicros,secs,micros))
  1338.                                          {
  1339.                                             mynode=CommandList.lh_Head;
  1340.  
  1341.                                             for(c=0;c<code;c++)
  1342.                                                mynode=mynode->Node.ln_Succ;
  1343.  
  1344.                                             if(LaunchCommand(mynode))
  1345.                                             {
  1346.                                                CleanUpMain();
  1347.                                                return;
  1348.                                             }
  1349.                                          }
  1350.                                       lastitem=code;
  1351.                                       oldsecs=secs;
  1352.                                       oldmicros=micros;
  1353.                                       break;
  1354.  
  1355.             case IDCMP_NEWSIZE:       RemoveGList(MainWindow,glist,-1);
  1356.                                       FreeGadgets(glist);
  1357.                                       Move(MainWindow->RPort,0,0);
  1358.                                       ClearScreen(MainWindow->RPort);
  1359.                                       RefreshWindowFrame(MainWindow);
  1360.                                       DrawMainGUI();
  1361.                                       break;
  1362.  
  1363.             case IDCMP_REFRESHWINDOW: GT_BeginRefresh(MainWindow);
  1364.                                       GT_EndRefresh(MainWindow,TRUE);
  1365.          }
  1366.       }
  1367.  
  1368.       if(sigs & wbsigflag)
  1369.       {
  1370.          ProcessWorkbench();
  1371.       }
  1372.  
  1373.       if(sigs & SIGBREAKF_CTRL_C)
  1374.       {
  1375.          if(MayExit())
  1376.          {
  1377.             CleanUpMain();
  1378.             CleanUp(0);
  1379.          }
  1380.       }
  1381.  
  1382.       if(sigs & wbappsigflag)
  1383.       {
  1384.          action=FALSE;
  1385.  
  1386.          while(appmsg = (struct AppMessage *)GetMsg(WBAppPort))
  1387.          {
  1388.             if(appmsg->am_Type == AMTYPE_APPMENUITEM)
  1389.                action=TRUE;
  1390.  
  1391.             ReplyMsg((struct Message *)appmsg);
  1392.          }
  1393.  
  1394.          if(action)
  1395.          {
  1396.             Appear();
  1397.          }
  1398.       }
  1399.  
  1400.       if(sigs & cxsigflag)
  1401.       {
  1402.          HandleCx();
  1403.  
  1404.          if(!MainWindow)
  1405.             return;
  1406.       }
  1407.    }
  1408. }
  1409.  
  1410. /* Initialization and background */
  1411.  
  1412. myputs(UBYTE *str)
  1413. {
  1414.    Write(Output(),str,strlen(str));
  1415. }
  1416.  
  1417. #include "wb2cli.h"
  1418.  
  1419. _main()
  1420. {
  1421.    ULONG sigs;
  1422.    struct AppMessage *appmsg;
  1423.    CxObj *tmpobj;
  1424.    BOOL action;
  1425.  
  1426.    WB2CLI(_WBMsg,4000,(struct DosLibrary *)DOSBase); /* Copy path etc */
  1427.  
  1428.    if(SysBase->LibNode.lib_Version<37)
  1429.    {
  1430.       if(!_WBMsg)
  1431.          myputs("Sorry! This program requires Kickstart 2.04 or higher\n");
  1432.  
  1433.       _exit(0);
  1434.    }
  1435.  
  1436.    NewList(&CommandList);
  1437.  
  1438.    if(!(KeymapBase=OpenLibrary("keymap.library",37)))
  1439.       CleanUp(10);
  1440.  
  1441.    if(!(CxBase=OpenLibrary("commodities.library",37)))
  1442.       CleanUp(10);
  1443.  
  1444.    if(LocaleBase=OpenLibrary("locale.library",37))
  1445.    {
  1446.       if (!(locale=OpenLocale(NULL)))
  1447.       {
  1448.          es.es_Title="CommandList Error";
  1449.          es.es_TextFormat="No locale set";
  1450.          es.es_GadgetFormat="Quit";
  1451.          EasyRequest(NULL,&es,NULL,NULL);
  1452.          CloseLibrary(LocaleBase);
  1453.          LocaleBase = NULL;
  1454.       }
  1455.  
  1456.       catalog=OpenCatalog(locale,"CommandList.catalog",OC_BuiltInLanguage, "english",
  1457.                                                        OC_Version,  0L,
  1458.                                                        TAG_DONE );
  1459.    }
  1460.  
  1461.    myproc=(struct Process *)FindTask(NULL);
  1462.  
  1463.    if(_WBMsg)
  1464.    {
  1465.       struct DiskObject *dobj;
  1466.       UBYTE *what;
  1467.       BPTR olddir;
  1468.  
  1469.       olddir=CurrentDir(_WBMsg->sm_ArgList->wa_Lock);
  1470.  
  1471.       if(!(dobj=GetDiskObject(_WBMsg->sm_ArgList->wa_Name)))
  1472.       {
  1473.          CurrentDir(olddir);
  1474.          CleanUp(10);
  1475.       }
  1476.  
  1477.       if(what=FindToolType(dobj->do_ToolTypes,"CX_POPKEY"))
  1478.       {
  1479.          strncpy(cfg_Popkey,what,48);
  1480.          cfg_Popkey[49]=0;
  1481.       }
  1482.  
  1483.       if(what=FindToolType(dobj->do_ToolTypes,"SETTINGS"))
  1484.       {
  1485.          strncpy(cfg_Settings,what,99);
  1486.          cfg_Settings[99]=0;
  1487.       }
  1488.  
  1489.       if(what=FindToolType(dobj->do_ToolTypes,"CX_POPUP"))
  1490.          if(stricmp(what,"YES")==0) cfg_Popup=TRUE;
  1491.  
  1492.       if(what=FindToolType(dobj->do_ToolTypes,"CX_PRIORITY"))
  1493.          newbroker.nb_Pri=atoi(what);
  1494.  
  1495.       FreeDiskObject(dobj);
  1496.       CurrentDir(olddir);
  1497.    }
  1498.    else
  1499.    {
  1500.       if(!(rdargs=(struct RDArgs *)ReadArgs(argstr,argarray,NULL)))
  1501.       {
  1502.          PrintFault(IoErr(),NULL);
  1503.          CleanUp(10);
  1504.       }
  1505.  
  1506.       if(argarray[CX_POPUP])
  1507.          cfg_Popup=TRUE;
  1508.  
  1509.       if(argarray[CX_POPKEY])
  1510.       {
  1511.          strncpy(cfg_Popkey,(UBYTE *)argarray[CX_POPKEY],48);
  1512.          cfg_Popkey[49]=0;
  1513.       }
  1514.  
  1515.       if(argarray[SETTINGS])
  1516.       {
  1517.          strncpy(cfg_Settings,(UBYTE *)argarray[SETTINGS],99);
  1518.          cfg_Settings[99]=0;
  1519.       }
  1520.  
  1521.       if(argarray[CX_PRIORITY])
  1522.          newbroker.nb_Pri=*(ULONG *)argarray[CX_PRIORITY];
  1523.    }
  1524.  
  1525.    LoadConfig(cfg_Settings);
  1526.    strcpy(asl_buf,cfg_Settings);
  1527.  
  1528.    newbroker.nb_Descr=getString(EXCHANGE_DESCR_STR);
  1529.  
  1530.    if(!(WBReplyPort = CreateMsgPort()))
  1531.    {
  1532.       DisplayBeep(NULL);
  1533.       CleanUp(10);
  1534.    }
  1535.  
  1536.    if(!(WBAppPort = CreateMsgPort()))
  1537.    {
  1538.       DisplayBeep(NULL);
  1539.       CleanUp(10);
  1540.    }
  1541.  
  1542.    if(!(newbroker.nb_Port = CreateMsgPort()))
  1543.    {
  1544.       DisplayBeep(NULL);
  1545.       CleanUp(10);
  1546.    }
  1547.  
  1548.    cxsigflag = 1 << newbroker.nb_Port->mp_SigBit;
  1549.    wbsigflag = 1 << WBReplyPort->mp_SigBit;
  1550.    wbappsigflag = 1 << WBAppPort->mp_SigBit;
  1551.  
  1552.    if(!(broker=CxBroker(&newbroker, NULL)))
  1553.    {
  1554.       /* Is already running, other copy automatically notified */
  1555.       CleanUp(0);
  1556.    }
  1557.  
  1558.    if(!(tmpobj = HotKey(cfg_Popkey,newbroker.nb_Port,POPKEY_EVENT)))
  1559.    {
  1560.       es.es_Title=getString(REQ_ERRTITLE_STR);
  1561.       es.es_TextFormat=getString(ERR_INVALID_HOTKEY_STR);
  1562.       es.es_GadgetFormat=getString(REQ_QUIT_STR);
  1563.  
  1564.       EasyRequest(NULL,&es,NULL,cfg_Popkey);
  1565.       CleanUp(10);
  1566.    }
  1567.  
  1568.    AttachCxObj(broker,tmpobj);
  1569.    CreateHotkeys();
  1570.    ActivateCxObj(broker,1);
  1571.  
  1572.    appmenuitem=AddAppMenuItem(0,NULL,"CommandList...",WBAppPort,TAG_END);
  1573.  
  1574.    if(cfg_Popup)
  1575.       Popup();
  1576.  
  1577.    for(;;)
  1578.    {
  1579.       sigs = Wait(SIGBREAKF_CTRL_C | cxsigflag | wbsigflag | wbappsigflag);
  1580.  
  1581.       if(sigs & SIGBREAKF_CTRL_C)
  1582.       {
  1583.          if(MayExit())
  1584.             CleanUp(0);
  1585.       }
  1586.  
  1587.       if(sigs & wbappsigflag)
  1588.       {
  1589.          action=FALSE;
  1590.  
  1591.          while(appmsg = (struct AppMessage *)GetMsg(WBAppPort))
  1592.          {
  1593.             if(appmsg->am_Type == AMTYPE_APPMENUITEM)
  1594.                action=TRUE;
  1595.  
  1596.             ReplyMsg((struct Message *)appmsg);
  1597.          }
  1598.  
  1599.          if(action)
  1600.          {
  1601.             Appear();
  1602.          }
  1603.       }
  1604.  
  1605.       if(sigs & wbsigflag)
  1606.       {
  1607.          ProcessWorkbench();
  1608.       }
  1609.  
  1610.       if(sigs & cxsigflag)
  1611.       {
  1612.          HandleCx();
  1613.       }
  1614.    }
  1615. }
  1616.  
  1617. struct Gadget *commandgadget,*cyclegadget,*stackgadget,*namegadget,*deletegadget,*addgadget,*hotkeygadget;
  1618. struct Gadget *upgadget,*downgadget,*listviewgadget;
  1619.  
  1620. struct NewGadget cfggadgets[12];
  1621.  
  1622. STRPTR cfgcyclestrings[3];
  1623.  
  1624. void ActivateNode(struct MyNode *mynode)
  1625. {
  1626.    GT_SetGadgetAttrs(hotkeygadget,CfgWindow,NULL,GTST_String,mynode->Hotkey,TAG_END);
  1627.    GT_SetGadgetAttrs(commandgadget,CfgWindow,NULL,GTST_String,mynode->Command,TAG_END);
  1628.  
  1629.    if(mynode->Type == WORKBENCH)
  1630.    {
  1631.       GT_SetGadgetAttrs(cyclegadget,CfgWindow,NULL,GTCY_Active,0,TAG_END);
  1632.       GT_SetGadgetAttrs(stackgadget,CfgWindow,NULL,GA_Disabled,TRUE,0,TAG_END);
  1633.    }
  1634.    else
  1635.    {
  1636.       GT_SetGadgetAttrs(cyclegadget,CfgWindow,NULL,GTCY_Active,1,TAG_END);
  1637.       GT_SetGadgetAttrs(stackgadget,CfgWindow,NULL,GA_Disabled,FALSE,0,TAG_END);
  1638.       GT_SetGadgetAttrs(stackgadget,CfgWindow,NULL,GTIN_Number,mynode->Stack,TAG_END);
  1639.    }
  1640.  
  1641.    if(mynode!=(struct MyNode *)CommandList.lh_TailPred)
  1642.    {
  1643.       GT_SetGadgetAttrs(downgadget,CfgWindow,NULL,GA_Disabled,FALSE,0,TAG_END);
  1644.    }
  1645.    else
  1646.    {
  1647.       GT_SetGadgetAttrs(downgadget,CfgWindow,NULL,GA_Disabled,TRUE,0,TAG_END);
  1648.    }
  1649.  
  1650.    if(mynode!=(struct MyNode *)CommandList.lh_Head)
  1651.    {
  1652.       GT_SetGadgetAttrs(upgadget,CfgWindow,NULL,GA_Disabled,FALSE,0,TAG_END);
  1653.    }
  1654.    else
  1655.    {
  1656.       GT_SetGadgetAttrs(upgadget,CfgWindow,NULL,GA_Disabled,TRUE,0,TAG_END);
  1657.    }
  1658.  
  1659.    return;
  1660. }
  1661.  
  1662. int Widest(int old,UBYTE *text,struct RastPort *rport)
  1663. {
  1664.    struct TextExtent te;
  1665.  
  1666.    TextExtent(rport,text,strlen(text),&te);
  1667.  
  1668.    if(te.te_Width > old)
  1669.       return(te.te_Width);
  1670.  
  1671.    return(old);
  1672. }
  1673.  
  1674. #define CFG_NAME      1
  1675. #define CFG_LISTVIEW  2
  1676. #define CFG_HOTKEY    3
  1677. #define CFG_COMMAND   4
  1678. #define CFG_GETFILE   5
  1679. #define CFG_CYCLE     6
  1680. #define CFG_STACK     7
  1681. #define CFG_ADD       8
  1682. #define CFG_DELETE    9
  1683. #define CFG_UP        10
  1684. #define CFG_DOWN      11
  1685.  
  1686. #define getgadgetstring(g) ((struct StringInfo *)g->SpecialInfo)->Buffer
  1687. #define getgadgetvalue(g)  ((struct StringInfo *)g->SpecialInfo)->LongInt
  1688.  
  1689. void CfgDisableAll(void)
  1690. {
  1691.    GT_SetGadgetAttrs(namegadget,CfgWindow,NULL,GA_Disabled,TRUE,0,TAG_END);
  1692.    GT_SetGadgetAttrs(hotkeygadget,CfgWindow,NULL,GA_Disabled,TRUE,0,TAG_END);
  1693.    GT_SetGadgetAttrs(commandgadget,CfgWindow,NULL,GA_Disabled,TRUE,0,TAG_END);
  1694.    GT_SetGadgetAttrs(cyclegadget,CfgWindow,NULL,GA_Disabled,TRUE,0,TAG_END);
  1695.    GT_SetGadgetAttrs(stackgadget,CfgWindow,NULL,GA_Disabled,TRUE,0,TAG_END);
  1696.    GT_SetGadgetAttrs(deletegadget,CfgWindow,NULL,GA_Disabled,TRUE,0,TAG_END);
  1697.    GT_SetGadgetAttrs(upgadget,CfgWindow,NULL,GA_Disabled,TRUE,0,TAG_END);
  1698.    GT_SetGadgetAttrs(downgadget,CfgWindow,NULL,GA_Disabled,TRUE,0,TAG_END);
  1699. }
  1700.  
  1701. void CfgEnableAll(void)
  1702. {
  1703.    GT_SetGadgetAttrs(namegadget,CfgWindow,NULL,GA_Disabled,FALSE,0,TAG_END);
  1704.    GT_SetGadgetAttrs(hotkeygadget,CfgWindow,NULL,GA_Disabled,FALSE,0,TAG_END);
  1705.    GT_SetGadgetAttrs(commandgadget,CfgWindow,NULL,GA_Disabled,FALSE,0,TAG_END);
  1706.    GT_SetGadgetAttrs(cyclegadget,CfgWindow,NULL,GA_Disabled,FALSE,0,TAG_END);
  1707.    GT_SetGadgetAttrs(stackgadget,CfgWindow,NULL,GA_Disabled,FALSE,0,TAG_END);
  1708.    GT_SetGadgetAttrs(deletegadget,CfgWindow,NULL,GA_Disabled,FALSE,0,TAG_END);
  1709.    GT_SetGadgetAttrs(upgadget,CfgWindow,NULL,GA_Disabled,FALSE,0,TAG_END);
  1710.    GT_SetGadgetAttrs(downgadget,CfgWindow,NULL,GA_Disabled,FALSE,0,TAG_END);
  1711. }
  1712.  
  1713. void DrawCfgGUI(void)
  1714. {
  1715.    struct Gadget *lastgad=NULL;
  1716.    ULONG listviewheight;
  1717.    ULONG buttonwidth=0,c;
  1718.  
  1719.    InnerHeight=CfgWindow->Height-CfgWindow->BorderTop-CfgWindow->BorderBottom;
  1720.    InnerWidth=CfgWindow->Width-CfgWindow->BorderLeft-CfgWindow->BorderRight;
  1721.  
  1722.    XOff=CfgWindow->BorderLeft;
  1723.    YOff=CfgWindow->BorderTop;
  1724.  
  1725.    buttonwidth=Widest(buttonwidth,getString(CFG_GAD_ADD_STR),CfgWindow->RPort);
  1726.    buttonwidth=Widest(buttonwidth,getString(CFG_GAD_DELETE_STR),CfgWindow->RPort);
  1727.    buttonwidth=Widest(buttonwidth,getString(CFG_GAD_UP_STR),CfgWindow->RPort);
  1728.    buttonwidth=Widest(buttonwidth,getString(CFG_GAD_DOWN_STR),CfgWindow->RPort);
  1729.  
  1730.    buttonwidth+=8+20;
  1731.  
  1732.    listviewheight=InnerHeight
  1733.                   -2                                     /* Mellanrum nere */
  1734.                   -3-PubScreen->Font->ta_YSize-3         /* Gadgetrad */
  1735.                   -4                                     /* Mellanrum */
  1736.                   -PubScreen->Font->ta_YSize             /* Text      */
  1737.                   -4                                     /* Mellanrum */
  1738.                   -3-PubScreen->Font->ta_YSize-3         /* Gadgetrad */
  1739.                   -4                                     /* Mellanrum */
  1740.                   -PubScreen->Font->ta_YSize             /* Text      */
  1741.                   -4
  1742.                   -3-PubScreen->Font->ta_YSize-3         /* Gadgetrad */
  1743.                   -4                                     /* Mellanrum */
  1744.                   -PubScreen->Font->ta_YSize             /* Text      */
  1745.                   -8                                     /* Mellanrum */
  1746.                   -2;                                    /* Mellanrum uppe */
  1747.  
  1748.    cfg_CfgLines=(listviewheight-4-6)/PubScreen->Font->ta_YSize-1;
  1749.    cfg_CfgInnerWidth=CfgWindow->Width-CfgWindow->BorderLeft-CfgWindow->BorderRight;
  1750.  
  1751.    cfgglist=NULL;
  1752.  
  1753.    lastgad=(struct Gadget *)CreateContext(&cfgglist);
  1754.  
  1755.    for(c=0;c<12;c++)
  1756.    {
  1757.       cfggadgets[c].ng_TextAttr=PubScreen->Font;
  1758.       cfggadgets[c].ng_VisualInfo=vi;
  1759.       cfggadgets[c].ng_GadgetID=c+1;
  1760.    }
  1761.  
  1762.    cfggadgets[0].ng_LeftEdge=0;
  1763.    cfggadgets[0].ng_TopEdge=0;
  1764.    cfggadgets[0].ng_Height=PubScreen->Font->ta_YSize+6;
  1765.    cfggadgets[0].ng_Width=InnerWidth-4-2-buttonwidth;
  1766.  
  1767.    lastgad = CreateGadget(STRING_KIND,lastgad,&cfggadgets[0],GTST_EditHook, &stredithook,GTST_MaxChars,39,TAG_END);
  1768.    namegadget=lastgad;
  1769.  
  1770.    cfggadgets[1].ng_LeftEdge=XOff+2;
  1771.    cfggadgets[1].ng_TopEdge=YOff+2;
  1772.    cfggadgets[1].ng_Height=listviewheight;
  1773.    cfggadgets[1].ng_Width=InnerWidth-4-2-buttonwidth;
  1774.  
  1775.    lastgad = CreateGadget(LISTVIEW_KIND,lastgad,&cfggadgets[1],GTLV_ShowSelected,lastgad,
  1776.                                                                GTLV_Labels,&CommandList,
  1777.                                                                TAG_END);
  1778.    listviewgadget=lastgad;
  1779.  
  1780.    cfggadgets[2].ng_LeftEdge=XOff+2;
  1781.    cfggadgets[2].ng_TopEdge=YOff+InnerHeight-2-PubScreen->Font->ta_YSize-6-4-PubScreen->Font->ta_YSize-4-PubScreen->Font->ta_YSize-6-PubScreen->Font->ta_YSize-6-4-PubScreen->Font->ta_YSize-4;
  1782.    cfggadgets[2].ng_Height=PubScreen->Font->ta_YSize+6;
  1783.    cfggadgets[2].ng_Width=InnerWidth-4;
  1784.    cfggadgets[2].ng_GadgetText=getString(CFG_GAD_HOTKEY_STR);
  1785.    cfggadgets[2].ng_Flags=PLACETEXT_ABOVE;
  1786.  
  1787.    lastgad = CreateGadget(STRING_KIND,lastgad,&cfggadgets[2],GTST_EditHook, &stredithook,GT_Underscore,'_',
  1788.                                                              GTST_MaxChars,199,TAG_END);
  1789.    hotkeygadget=lastgad;
  1790.  
  1791.    cfggadgets[3].ng_LeftEdge=XOff+2;
  1792.    cfggadgets[3].ng_TopEdge=YOff+InnerHeight-2-PubScreen->Font->ta_YSize-6-4-PubScreen->Font->ta_YSize-4-PubScreen->Font->ta_YSize-6;
  1793.    cfggadgets[3].ng_Height=PubScreen->Font->ta_YSize+6;
  1794.    cfggadgets[3].ng_Width=InnerWidth-4-20;
  1795.  
  1796.    lastgad = CreateGadget(STRING_KIND,lastgad,&cfggadgets[3],GTST_EditHook, &stredithook,GT_Underscore,'_',
  1797.                                                              GTST_MaxChars,199,TAG_END);
  1798.    commandgadget=lastgad;
  1799.  
  1800.    cfggadgets[4].ng_LeftEdge=XOff+2+InnerWidth-4-20;
  1801.    cfggadgets[4].ng_TopEdge=YOff+InnerHeight-2-PubScreen->Font->ta_YSize-6-4-PubScreen->Font->ta_YSize-4-PubScreen->Font->ta_YSize-6;
  1802.    cfggadgets[4].ng_Height=PubScreen->Font->ta_YSize+6;
  1803.    cfggadgets[4].ng_Width=20;
  1804.  
  1805.    lastgad = CreateGadget(GENERIC_KIND,lastgad,&cfggadgets[4],TAG_END);
  1806.  
  1807.    getfileimg = NewObject(altclass, NULL, IA_Width,  20,
  1808.                                           IA_Height, PubScreen->Font->ta_YSize+6,
  1809.                                           ALT_Image, ALTI_GetFile,
  1810.                                           TAG_END);
  1811.  
  1812.    lastgad->GadgetRender = getfileimg;
  1813.    lastgad->SelectRender = getfileimg;
  1814.    lastgad->Flags       |= GFLG_GADGIMAGE | GFLG_GADGHIMAGE;
  1815.    lastgad->Activation  |= GACT_RELVERIFY;
  1816.    lastgad->GadgetType  |= GTYP_BOOLGADGET;
  1817.  
  1818.    cfgcyclestrings[0]=getString(CFG_GAD_WB_STR);
  1819.    cfgcyclestrings[1]=getString(CFG_GAD_CLI_STR);
  1820.    cfgcyclestrings[2]=NULL;
  1821.  
  1822.    cfggadgets[5].ng_LeftEdge=XOff+2;
  1823.    cfggadgets[5].ng_TopEdge=YOff+InnerHeight-2-PubScreen->Font->ta_YSize-6;
  1824.    cfggadgets[5].ng_Height=PubScreen->Font->ta_YSize+6;
  1825.    cfggadgets[5].ng_Width=(InnerWidth-4-2)/2;
  1826.    cfggadgets[5].ng_GadgetText=getString(CFG_GAD_TYPE_STR);
  1827.    cfggadgets[5].ng_Flags=PLACETEXT_ABOVE;
  1828.  
  1829.    lastgad = CreateGadget(CYCLE_KIND,lastgad,&cfggadgets[5],GT_Underscore,'_',GTCY_Labels,cfgcyclestrings,TAG_END);
  1830.    cyclegadget=lastgad;
  1831.  
  1832.    cfggadgets[6].ng_LeftEdge=XOff+InnerWidth-2-(InnerWidth-4-2)/2;
  1833.    cfggadgets[6].ng_TopEdge=YOff+InnerHeight-2-PubScreen->Font->ta_YSize-6;
  1834.    cfggadgets[6].ng_Height=PubScreen->Font->ta_YSize+6;
  1835.    cfggadgets[6].ng_Width=(InnerWidth-4-2)/2;
  1836.    cfggadgets[6].ng_GadgetText=getString(CFG_GAD_STACK_STR);
  1837.    cfggadgets[6].ng_Flags=PLACETEXT_ABOVE;
  1838.  
  1839.    lastgad = CreateGadget(INTEGER_KIND,lastgad,&cfggadgets[6],GTIN_EditHook,&stredithook,GT_Underscore,'_',TAG_END);
  1840.    stackgadget=lastgad;
  1841.  
  1842.    cfggadgets[7].ng_LeftEdge=XOff+InnerWidth-2-buttonwidth;
  1843.    cfggadgets[7].ng_TopEdge=YOff+2;
  1844.    cfggadgets[7].ng_Height=PubScreen->Font->ta_YSize+4;
  1845.    cfggadgets[7].ng_Width=buttonwidth;
  1846.    cfggadgets[7].ng_GadgetText=getString(CFG_GAD_ADD_STR);
  1847.  
  1848.    lastgad = CreateGadget(BUTTON_KIND,lastgad,&cfggadgets[7],GT_Underscore,'_',TAG_END);
  1849.    addgadget=lastgad;
  1850.  
  1851.    cfggadgets[8].ng_LeftEdge=XOff+InnerWidth-2-buttonwidth;
  1852.    cfggadgets[8].ng_TopEdge=YOff+2+PubScreen->Font->ta_YSize+4+2;
  1853.    cfggadgets[8].ng_Height=PubScreen->Font->ta_YSize+4;
  1854.    cfggadgets[8].ng_Width=buttonwidth;
  1855.    cfggadgets[8].ng_GadgetText=getString(CFG_GAD_DELETE_STR);
  1856.  
  1857.    lastgad = CreateGadget(BUTTON_KIND,lastgad,&cfggadgets[8],GT_Underscore,'_',TAG_END);
  1858.    deletegadget=lastgad;
  1859.  
  1860.    cfggadgets[9].ng_LeftEdge=XOff+InnerWidth-2-buttonwidth;
  1861.    cfggadgets[9].ng_TopEdge=YOff+2+PubScreen->Font->ta_YSize+4+2+PubScreen->Font->ta_YSize+4+2;
  1862.    cfggadgets[9].ng_Height=PubScreen->Font->ta_YSize+4;
  1863.    cfggadgets[9].ng_Width=buttonwidth;
  1864.    cfggadgets[9].ng_GadgetText=getString(CFG_GAD_UP_STR);
  1865.  
  1866.    lastgad = CreateGadget(BUTTON_KIND,lastgad,&cfggadgets[9],GT_Underscore,'_',TAG_END);
  1867.    upgadget=lastgad;
  1868.  
  1869.    cfggadgets[10].ng_LeftEdge=XOff+InnerWidth-2-buttonwidth;
  1870.    cfggadgets[10].ng_TopEdge=YOff+2+PubScreen->Font->ta_YSize+4+2+PubScreen->Font->ta_YSize+4+2+PubScreen->Font->ta_YSize+4+2;
  1871.    cfggadgets[10].ng_Height=PubScreen->Font->ta_YSize+4;
  1872.    cfggadgets[10].ng_Width=buttonwidth;
  1873.    cfggadgets[10].ng_GadgetText=getString(CFG_GAD_DOWN_STR);
  1874.  
  1875.    lastgad = CreateGadget(BUTTON_KIND,lastgad,&cfggadgets[10],GT_Underscore,'_',TAG_END);
  1876.    downgadget=lastgad;
  1877.  
  1878.    /* An invisible TEXT_KIND gadget. An easy way to draw a centered text
  1879.       with the shortcut underlines. */
  1880.  
  1881.    cfggadgets[11].ng_LeftEdge=XOff+2;
  1882.    cfggadgets[11].ng_TopEdge=YOff+InnerHeight-2-PubScreen->Font->ta_YSize-6-4-PubScreen->Font->ta_YSize-4-PubScreen->Font->ta_YSize-6-4-PubScreen->Font->ta_YSize-2;
  1883.    cfggadgets[11].ng_Height=PubScreen->Font->ta_YSize+4;
  1884.    cfggadgets[11].ng_Width=InnerWidth-4;
  1885.    cfggadgets[11].ng_GadgetText=getString(CFG_GAD_COMMAND_STR);
  1886.    cfggadgets[11].ng_Flags=PLACETEXT_IN;
  1887.  
  1888.    lastgad = CreateGadget(TEXT_KIND,lastgad,&cfggadgets[11],GT_Underscore,'_',TAG_END);
  1889.  
  1890.    AddGList(CfgWindow,cfgglist,-1,-1,NULL);
  1891.    RefreshGList(cfgglist,CfgWindow,NULL,-1);
  1892.    GT_RefreshWindow(CfgWindow,NULL);
  1893.  
  1894.    if(maxlist!=0)
  1895.    {
  1896.       GT_SetGadgetAttrs(listviewgadget,CfgWindow,NULL,GTLV_Selected,cfglastitem,TAG_END);
  1897.       MakeVisible(cfglastitem,cfg_CfgLines,listviewgadget,CfgWindow);
  1898.  
  1899.       if(cfglastnode)
  1900.          ActivateNode(cfglastnode);
  1901.  
  1902.       else
  1903.       {
  1904.          ActivateNode((struct MyNode *)CommandList.lh_Head);
  1905.          cfglastnode=(struct MyNode *)CommandList.lh_Head;
  1906.       }
  1907.    }
  1908.    else
  1909.    {
  1910.       CfgDisableAll();
  1911.    }
  1912. }
  1913.  
  1914. void CleanUpCfg(void)
  1915. {
  1916.    if(appwindow)  RemoveAppWindow(appwindow);
  1917.    if(CfgWindow)  CloseWindow(CfgWindow);
  1918.    if(cfgglist)   FreeGadgets(cfgglist);
  1919.    if(cfgfib)     FreeMem(cfgfib,sizeof(struct FileInfoBlock));
  1920.    if(getfileimg) DisposeObject(getfileimg);
  1921.    if(altclass)   FreeClass(altclass);
  1922.  
  1923.    CfgWindow=NULL;
  1924.    cfgglist=NULL;
  1925.    appwindow=NULL;
  1926.    cfgfib=NULL;
  1927.    altclass=NULL;
  1928.    getfileimg=NULL;
  1929. }
  1930.  
  1931. void SwapMyNodes(struct MyNode *n1,struct MyNode *n2)
  1932. {
  1933.    UBYTE namebak[40],commandbak[200],keybak[40],typebak;
  1934.    ULONG stackbak;
  1935.  
  1936.    strcpy(namebak,n1->Name);
  1937.    strcpy(commandbak,n1->Command);
  1938.    strcpy(keybak,n1->Hotkey);
  1939.    typebak=n1->Type;
  1940.    stackbak=n1->Stack;
  1941.  
  1942.    strcpy(n1->Name,n2->Name);
  1943.    strcpy(n1->Command,n2->Command);
  1944.    strcpy(n1->Hotkey,n2->Hotkey);
  1945.    n1->Type=n2->Type;
  1946.    n1->Stack=n2->Stack;
  1947.  
  1948.    strcpy(n2->Name,namebak);
  1949.    strcpy(n2->Command,commandbak);
  1950.    strcpy(n2->Hotkey,keybak);
  1951.    n2->Type=typebak;
  1952.    n2->Stack=stackbak;
  1953. }
  1954.  
  1955. void CfgUp(void)
  1956. {
  1957.   if(cfglastnode == (struct MyNode *)CommandList.lh_Head)
  1958.    return;
  1959.  
  1960.   GT_SetGadgetAttrs(listviewgadget,CfgWindow,NULL,GTLV_Labels,~0,TAG_END);
  1961.   SwapMyNodes(cfglastnode,(struct MyNode *)cfglastnode->Node.ln_Pred);
  1962.   cfglastitem--;
  1963.   cfglastnode=(struct MyNode *)cfglastnode->Node.ln_Pred;
  1964.   GT_SetGadgetAttrs(listviewgadget,CfgWindow,NULL,GTLV_Labels,&CommandList,TAG_END);
  1965.   GT_SetGadgetAttrs(listviewgadget,CfgWindow,NULL,GTLV_Selected,cfglastitem,TAG_END);
  1966.   MakeVisible(cfglastitem,cfg_CfgLines,listviewgadget,CfgWindow);
  1967.   ActivateNode(cfglastnode);
  1968. }
  1969.  
  1970. void CfgDown(void)
  1971. {
  1972.   if(cfglastnode == (struct MyNode *)CommandList.lh_TailPred)
  1973.    return;
  1974.  
  1975.   GT_SetGadgetAttrs(listviewgadget,CfgWindow,NULL,GTLV_Labels,~0,TAG_END);
  1976.   SwapMyNodes(cfglastnode,(struct MyNode *)cfglastnode->Node.ln_Succ);
  1977.   cfglastitem++;
  1978.   cfglastnode=(struct MyNode *)cfglastnode->Node.ln_Succ;
  1979.   GT_SetGadgetAttrs(listviewgadget,CfgWindow,NULL,GTLV_Labels,&CommandList,TAG_END);
  1980.   GT_SetGadgetAttrs(listviewgadget,CfgWindow,NULL,GTLV_Selected,cfglastitem,TAG_END);
  1981.   MakeVisible(cfglastitem,cfg_CfgLines,listviewgadget,CfgWindow);
  1982.   ActivateNode(cfglastnode);
  1983. }
  1984.  
  1985. void CfgDelete(void)
  1986. {
  1987.    struct MyNode *mynode;
  1988.    UBYTE buf[50];
  1989.  
  1990.    LockWindow(CfgWindow);
  1991.  
  1992.    strcpy(buf,getString(REQ_DELETE_STR));
  1993.    strcat(buf,"|");
  1994.    strcat(buf,getString(REQ_CANCEL_STR));
  1995.  
  1996.    es.es_Title=getString(REQ_REQUEST_STR);
  1997.    es.es_TextFormat=getString(REQ_DELETETEXT_STR);
  1998.    es.es_GadgetFormat=buf;
  1999.  
  2000.    if(!(EasyRequest(NULL,&es,NULL,cfglastnode->Name)))
  2001.    {
  2002.       UnLockWindow(CfgWindow);
  2003.       return;
  2004.    }
  2005.  
  2006.    UnLockWindow(CfgWindow);
  2007.  
  2008.    GT_SetGadgetAttrs(listviewgadget,CfgWindow,NULL,GTLV_Labels,~0,TAG_END);
  2009.  
  2010.    mynode=cfglastnode;
  2011.  
  2012.    if(cfglastitem != maxlist-1)
  2013.    {
  2014.       cfglastnode=cfglastnode->Node.ln_Succ;
  2015.    }
  2016.    else if(cfglastitem != 0)
  2017.    {
  2018.       cfglastnode=cfglastnode->Node.ln_Pred;
  2019.       cfglastitem--;
  2020.    }
  2021.    else
  2022.    {
  2023.       cfglastnode=NULL;
  2024.       cfglastitem=0;
  2025.       CfgDisableAll();
  2026.    }
  2027.  
  2028.    maxlist--;
  2029.    Remove((struct Node *)mynode);
  2030.    FreeMem(mynode,sizeof(struct MyNode));
  2031.    GT_SetGadgetAttrs(listviewgadget,CfgWindow,NULL,GTLV_Labels,&CommandList,TAG_END);
  2032.    if(cfglastnode) ActivateNode(cfglastnode);
  2033. }
  2034.  
  2035. void CfgAdd(void)
  2036. {
  2037.    struct MyNode *mynode;
  2038.  
  2039.    if(mynode=(struct MyNode *)AllocMem(sizeof(struct MyNode),MEMF_CLEAR))
  2040.    {
  2041.       GT_SetGadgetAttrs(listviewgadget,CfgWindow,NULL,GTLV_Labels,~0,TAG_END);
  2042.       mynode->Type=WORKBENCH;
  2043.       mynode->Stack=4000;
  2044.       strcpy(mynode->Name,getString(CFG_NEW_ITEM_STR));
  2045.       strcpy(mynode->Command,"");
  2046.       mynode->Node.ln_Name=mynode->Name;
  2047.       AddTail(&CommandList,(struct Node *)mynode);
  2048.       maxlist++;
  2049.       cfglastitem=maxlist-1;
  2050.       cfglastnode=CommandList.lh_TailPred;
  2051.       CfgEnableAll();
  2052.       GT_SetGadgetAttrs(listviewgadget,CfgWindow,NULL,GTLV_Labels,&CommandList,TAG_END);
  2053.       GT_SetGadgetAttrs(listviewgadget,CfgWindow,NULL,GTLV_Selected,cfglastitem,TAG_END);
  2054.       MakeVisible(cfglastitem,cfg_CfgLines,listviewgadget,CfgWindow);
  2055.       ActivateNode(cfglastnode);
  2056.       ActivateGadget(namegadget,CfgWindow,NULL);
  2057.    }
  2058.    else
  2059.    {
  2060.       DisplayBeep(NULL);
  2061.    }
  2062. }
  2063.  
  2064. void Config(void)
  2065. {
  2066.    ULONG sigs,class,code,c,qualifier,actual;
  2067.    ULONG xpos,ypos,buttonwidth=0,CfgWindowInnerHeight;
  2068.    struct IntuiMessage *IntuiMessage;
  2069.    struct AppMessage *appmsg;
  2070.    APTR iaddress;
  2071.    BOOL action;
  2072.    struct WBArg *arglist;
  2073.    BPTR l,olddir;
  2074.    struct MyNode *mynode;
  2075.    struct DiskObject *dobj;
  2076.    struct InputEvent ie;
  2077.    UBYTE buf[100];
  2078.    CxObj *tmpobj;
  2079.  
  2080.    if(!(altclass=InitAltClass()))
  2081.    {
  2082.       DisplayBeep(NULL);
  2083.       CleanUpCfg();
  2084.       return;
  2085.    }
  2086.  
  2087.    if(!(cfgfib=(struct FileInfoBlock *)AllocMem(sizeof(struct FileInfoBlock),MEMF_ANY)))
  2088.    {
  2089.       DisplayBeep(NULL);
  2090.       CleanUpCfg();
  2091.       return;
  2092.    }
  2093.  
  2094.    cfglastitem=0;
  2095.    cfglastnode=NULL;
  2096.  
  2097.    ypos=PubScreen->MouseY-PubScreen->WBorTop-PubScreen->Font->ta_YSize-1-1-2-PubScreen->Font->ta_YSize/2;
  2098.  
  2099.    if(ypos<0)
  2100.       ypos=0;
  2101.  
  2102.    xpos=PubScreen->MouseX-20;
  2103.  
  2104.    if(xpos<0)
  2105.       xpos=0;
  2106.  
  2107.    buttonwidth=Widest(buttonwidth,getString(CFG_GAD_ADD_STR),MainWindow->RPort);
  2108.    buttonwidth=Widest(buttonwidth,getString(CFG_GAD_DELETE_STR),MainWindow->RPort);
  2109.    buttonwidth=Widest(buttonwidth,getString(CFG_GAD_UP_STR),MainWindow->RPort);
  2110.    buttonwidth=Widest(buttonwidth,getString(CFG_GAD_DOWN_STR),MainWindow->RPort);
  2111.  
  2112.    buttonwidth+=8+20;
  2113.  
  2114.    CfgWindowMinWidth=buttonwidth*2+2+2+2;
  2115.  
  2116.    if(cfg_CfgInnerWidth < CfgWindowMinWidth)
  2117.       cfg_CfgInnerWidth=CfgWindowMinWidth;
  2118.  
  2119.    CfgWindowMinHeight=+2
  2120.                       +4*(PubScreen->Font->ta_YSize+4)
  2121.                       +3*2
  2122.                       +8
  2123.                       +PubScreen->Font->ta_YSize
  2124.                       +4
  2125.                       +3+PubScreen->Font->ta_YSize+3
  2126.                       +4
  2127.                       +PubScreen->Font->ta_YSize
  2128.                       +4
  2129.                       +3+PubScreen->Font->ta_YSize+3
  2130.                       +4
  2131.                       +PubScreen->Font->ta_YSize
  2132.                       +4
  2133.                       +3+PubScreen->Font->ta_YSize+3
  2134.                       +2;
  2135.  
  2136.    CfgWindowInnerHeight=2
  2137.                         +(cfg_CfgLines+1)*PubScreen->Font->ta_YSize+4+6
  2138.                         +8
  2139.                         +PubScreen->Font->ta_YSize
  2140.                         +4
  2141.                         +3+PubScreen->Font->ta_YSize+3
  2142.                         +4
  2143.                         +PubScreen->Font->ta_YSize
  2144.                         +4
  2145.                         +3+PubScreen->Font->ta_YSize+3
  2146.                         +4
  2147.                         +PubScreen->Font->ta_YSize
  2148.                         +4
  2149.                         +3+PubScreen->Font->ta_YSize+3
  2150.                         +2;
  2151.  
  2152.    if(CfgWindowInnerHeight < CfgWindowMinHeight)
  2153.       CfgWindowInnerHeight=CfgWindowMinHeight;
  2154.  
  2155.    if(!(CfgWindow=OpenWindowTags(NULL,WA_Left,               xpos,
  2156.                                       WA_Top,                ypos,
  2157.                                       WA_InnerWidth,         cfg_CfgInnerWidth,
  2158.                                       WA_InnerHeight,        CfgWindowInnerHeight,
  2159.                                       WA_MinWidth,           200,
  2160.                                       WA_MinHeight,          100,
  2161.                                       WA_MaxWidth,           -1,
  2162.                                       WA_MaxHeight,          -1,
  2163.                                       WA_AutoAdjust,         TRUE,
  2164.                                       WA_Flags,              WFLG_SIZEGADGET|WFLG_SIZEBBOTTOM|WFLG_ACTIVATE|WFLG_CLOSEGADGET|WFLG_DEPTHGADGET|WFLG_DRAGBAR|WFLG_NEWLOOKMENUS,
  2165.                                       WA_IDCMP,              IDCMP_NEWSIZE|IDCMP_CLOSEWINDOW|LISTVIEWIDCMP|IDCMP_RAWKEY|IDCMP_MENUPICK|IDCMP_INACTIVEWINDOW,
  2166.                                       WA_Title,              getString(MAIN_MENU_EDITCOMMANDS_STR),
  2167.                                       WA_PubScreenName,      PubScreenName,
  2168.                                       WA_PubScreenFallBack,  TRUE,
  2169.                                       TAG_END)))
  2170.    {
  2171.       DisplayBeep(NULL);
  2172.       CleanUpCfg();
  2173.       return;
  2174.    }
  2175.  
  2176.    CfgWindowMinWidth+=MainWindow->BorderRight+MainWindow->BorderLeft;
  2177.    CfgWindowMinHeight+=MainWindow->BorderTop+MainWindow->BorderBottom;
  2178.  
  2179.    WindowLimits(CfgWindow,CfgWindowMinWidth,CfgWindowMinHeight,-1,-1);
  2180.  
  2181.    SetFont(CfgWindow->RPort,textfont);
  2182.    DrawCfgGUI();
  2183.  
  2184.    appwindow=(struct AppWindow *)AddAppWindow(0,NULL,CfgWindow,WBAppPort,TAG_END);
  2185.  
  2186.    for(;;)
  2187.    {
  2188.       sigs = Wait(1<<CfgWindow->UserPort->mp_SigBit | cxsigflag | wbsigflag | SIGBREAKF_CTRL_C | wbappsigflag);
  2189.  
  2190.       while(IntuiMessage=(struct IntuiMessage *)GT_GetIMsg(CfgWindow->UserPort))
  2191.       {
  2192.          class=IntuiMessage->Class;
  2193.          code=IntuiMessage->Code;
  2194.          iaddress=IntuiMessage->IAddress;
  2195.          qualifier=IntuiMessage->Qualifier;
  2196.          GT_ReplyIMsg(IntuiMessage);
  2197.  
  2198.          switch(class)
  2199.          {
  2200.             case IDCMP_CLOSEWINDOW:   CleanUpCfg();
  2201.                                       return;
  2202.  
  2203.             case IDCMP_GADGETUP:      switch(((struct Gadget *)iaddress)->GadgetID)
  2204.                                       {
  2205.                                          case CFG_LISTVIEW:
  2206.                                             cfglastnode=CommandList.lh_Head;
  2207.  
  2208.                                             for(c=0;c<code;c++)
  2209.                                                cfglastnode=cfglastnode->Node.ln_Succ;
  2210.  
  2211.                                             ActivateNode(cfglastnode);
  2212.                                             cfglastitem=code;
  2213.                                             break;
  2214.                                          case CFG_NAME:
  2215.                                             GT_SetGadgetAttrs(listviewgadget,CfgWindow,NULL,GTLV_Labels,~0,TAG_END);
  2216.                                             strcpy(cfglastnode->Name,getgadgetstring(namegadget));
  2217.                                             GT_SetGadgetAttrs(listviewgadget,CfgWindow,NULL,GTLV_Labels,&CommandList,TAG_END);
  2218.                                             break;
  2219.                                          case CFG_HOTKEY:
  2220.                                             GT_SetGadgetAttrs(listviewgadget,CfgWindow,NULL,GTLV_Labels,~0,TAG_END);
  2221.                                             strcpy(cfglastnode->Hotkey,getgadgetstring(hotkeygadget));
  2222.                                             GT_SetGadgetAttrs(listviewgadget,CfgWindow,NULL,GTLV_Labels,&CommandList,TAG_END);
  2223.  
  2224.                                             if(cfglastnode->Hotkey[0])
  2225.                                             {
  2226.                                                if(!(tmpobj=HotKey(cfglastnode->Hotkey,newbroker.nb_Port,0)))
  2227.                                                {
  2228.                                                   es.es_Title=getString(REQ_ERRTITLE_STR);
  2229.                                                   es.es_TextFormat=getString(ERR_INVALID_HOTKEY_STR);
  2230.                                                   es.es_GadgetFormat=getString(REQ_PROCEED_STR);
  2231.                                                   LockWindow(CfgWindow);
  2232.                                                   EasyRequest(CfgWindow,&es,NULL,cfglastnode->Hotkey);
  2233.                                                   UnLockWindow(CfgWindow);
  2234.                                                   ActivateGadget(hotkeygadget,CfgWindow,NULL);
  2235.                                                }
  2236.                                                else
  2237.                                                {
  2238.                                                   DeleteCxObj(tmpobj);
  2239.                                                }
  2240.                                             }
  2241.                                             break;
  2242.                                          case CFG_COMMAND:
  2243.                                             GT_SetGadgetAttrs(listviewgadget,CfgWindow,NULL,GTLV_Labels,~0,TAG_END);
  2244.                                             strcpy(cfglastnode->Command,getgadgetstring(commandgadget));
  2245.                                             GT_SetGadgetAttrs(listviewgadget,CfgWindow,NULL,GTLV_Labels,&CommandList,TAG_END);
  2246.                                             break;
  2247.                                          case CFG_STACK:
  2248.                                             GT_SetGadgetAttrs(listviewgadget,CfgWindow,NULL,GTLV_Labels,~0,TAG_END);
  2249.                                             cfglastnode->Stack=getgadgetvalue(stackgadget);
  2250.                                             GT_SetGadgetAttrs(listviewgadget,CfgWindow,NULL,GTLV_Labels,&CommandList,TAG_END);
  2251.                                             break;
  2252.                                          case CFG_CYCLE:
  2253.                                             GT_SetGadgetAttrs(listviewgadget,CfgWindow,NULL,GTLV_Labels,~0,TAG_END);
  2254.  
  2255.                                             if(code == 0)
  2256.                                                cfglastnode->Type=WORKBENCH;
  2257.                                             else
  2258.                                                cfglastnode->Type=CLI;
  2259.  
  2260.                                             GT_SetGadgetAttrs(listviewgadget,CfgWindow,NULL,GTLV_Labels,&CommandList,TAG_END);
  2261.                                             ActivateNode(cfglastnode);
  2262.                                             break;
  2263.                                          case CFG_DELETE:
  2264.                                             CfgDelete();
  2265.                                             break;
  2266.                                          case CFG_ADD:
  2267.                                             CfgAdd();
  2268.                                             break;
  2269.                                          case CFG_UP:
  2270.                                             CfgUp();
  2271.                                             break;
  2272.                                          case CFG_DOWN:
  2273.                                             CfgDown();
  2274.                                             break;
  2275.                                          case CFG_GETFILE:
  2276.                                             LockWindow(CfgWindow);
  2277.                                             OpenAsl(cfglastnode->Command,getString(CFG_REQ_TITLE_STR),FALSE);
  2278.                                             UnLockWindow(CfgWindow);
  2279.                                             GT_SetGadgetAttrs(commandgadget,CfgWindow,NULL,GTST_String,cfglastnode->Command,TAG_END);
  2280.                                       }
  2281.                                       break;
  2282.  
  2283.             case IDCMP_RAWKEY:        action=TRUE;
  2284.  
  2285.                                       if((code == CURSORUP && (qualifier & QUAL_SHIFT)) || code == NUMPAD_9)
  2286.                                       {
  2287.                                          if(ListViewTop(listviewgadget,CfgWindow)==cfglastitem)
  2288.                                             cfglastitem-=cfg_CfgLines-1;
  2289.  
  2290.                                          else
  2291.                                             cfglastitem=ListViewTop(listviewgadget,CfgWindow);
  2292.  
  2293.                                          if(cfglastitem<0)
  2294.                                             cfglastitem=0;
  2295.                                       }
  2296.                                       else if((code == CURSORUP && (qualifier & IEQUALIFIER_CONTROL)) || code == NUMPAD_7)
  2297.                                       {
  2298.                                          cfglastitem=0;
  2299.                                       }
  2300.                                       else if(code == CURSORUP || code == NUMPAD_8)
  2301.                                       {
  2302.                                          if(cfglastitem>0)
  2303.                                             cfglastitem--;
  2304.                                       }
  2305.                                       else if((code == CURSORDOWN && (qualifier & QUAL_SHIFT)) || code == NUMPAD_3)
  2306.                                       {
  2307.                                          if(ListViewTop(listviewgadget,CfgWindow)+cfg_CfgLines-1==cfglastitem)
  2308.                                             cfglastitem+=cfg_CfgLines-1;
  2309.  
  2310.                                          else
  2311.                                            cfglastitem=ListViewTop(listviewgadget,CfgWindow)+cfg_CfgLines-1;
  2312.  
  2313.                                          if(cfglastitem>=maxlist)
  2314.                                            cfglastitem=maxlist-1;
  2315.                                       }
  2316.                                       else if((code == CURSORDOWN && (qualifier & IEQUALIFIER_CONTROL)) || code == NUMPAD_1)
  2317.                                       {
  2318.                                          cfglastitem=maxlist-1;
  2319.                                       }
  2320.                                       else if(code == CURSORDOWN || code == NUMPAD_2)
  2321.                                       {
  2322.                                          if(cfglastitem<maxlist-1)
  2323.                                             cfglastitem++;
  2324.                                       }
  2325.                                       else
  2326.                                       {
  2327.                                          action=FALSE;
  2328.                                       }
  2329.  
  2330.                                       if(action)
  2331.                                       {
  2332.                                          cfglastnode=CommandList.lh_Head;
  2333.  
  2334.                                          for(c=0;c<cfglastitem;c++)
  2335.                                             cfglastnode=cfglastnode->Node.ln_Succ;
  2336.  
  2337.                                          ActivateNode(cfglastnode);
  2338.  
  2339.                                          GT_SetGadgetAttrs(listviewgadget,CfgWindow,NULL,GTLV_Selected,cfglastitem,TAG_END);
  2340.                                          MakeVisible(cfglastitem,cfg_CfgLines,listviewgadget,CfgWindow);
  2341.                                       }
  2342.  
  2343.                                       if(code == ESC)
  2344.                                       {
  2345.                                          CleanUpCfg();
  2346.                                          return;
  2347.                                       }
  2348.  
  2349.                                       if(code == TAB && maxlist!=0)
  2350.                                       {
  2351.                                          ActivateGadget(namegadget,CfgWindow,NULL);
  2352.                                       }
  2353.  
  2354.                                       if(!action)
  2355.                                       {
  2356.                                             ie.ie_Class = IECLASS_RAWKEY;
  2357.                                          ie.ie_SubClass = 0;
  2358.                                          ie.ie_Code = code;
  2359.                                          ie.ie_Qualifier = qualifier;
  2360.                                          /* recover dead key codes & qualifiers */
  2361.                                          ie.ie_EventAddress = (APTR *) *((ULONG *)iaddress);
  2362.                                          actual = MapRawKey(&ie,buf,99,0);
  2363.  
  2364.                                          for (c = 0; c < actual; c++)
  2365.                                          {
  2366.                                             if(ToUpper(buf[c])==*getString(CFG_GAD_COMMAND_KEY) && maxlist!=0)
  2367.                                             {
  2368.                                                ActivateGadget(commandgadget,CfgWindow,NULL);
  2369.                                             }
  2370.  
  2371.                                             if(ToUpper(buf[c])==*getString(CFG_GAD_HOTKEY_KEY) && maxlist!=0)
  2372.                                             {
  2373.                                                ActivateGadget(hotkeygadget,CfgWindow,NULL);
  2374.                                             }
  2375.  
  2376.                                             if(ToUpper(buf[c])==*getString(CFG_GAD_STACK_KEY) && maxlist!=0)
  2377.                                             {
  2378.                                                if(cfglastnode->Type == CLI)
  2379.                                                   ActivateGadget(stackgadget,CfgWindow,NULL);
  2380.                                             }
  2381.  
  2382.                                             if(ToUpper(buf[c])==*getString(CFG_GAD_ADD_KEY))
  2383.                                             {
  2384.                                                if(FakePress(addgadget,CfgWindow,code))
  2385.                                                   CfgAdd();
  2386.                                             }
  2387.  
  2388.                                             if(ToUpper(buf[c])==*getString(CFG_GAD_DELETE_KEY) && maxlist!=0)
  2389.                                             {
  2390.                                                if(FakePress(deletegadget,CfgWindow,code))
  2391.                                                   CfgDelete();
  2392.                                             }
  2393.  
  2394.                                             if(ToUpper(buf[c])==*getString(CFG_GAD_UP_KEY) && maxlist!=0)
  2395.                                             {
  2396.                                                if(cfglastnode!=(struct MyNode *)CommandList.lh_Head)
  2397.                                                   if(FakePress(upgadget,CfgWindow,code))
  2398.                                                      CfgUp();
  2399.                                             }
  2400.  
  2401.                                             if(ToUpper(buf[c])==*getString(CFG_GAD_DOWN_KEY) && maxlist!=0)
  2402.                                             {
  2403.                                                if(cfglastnode!=(struct MyNode *)CommandList.lh_TailPred)
  2404.                                                   if(FakePress(downgadget,CfgWindow,code))
  2405.                                                      CfgDown();
  2406.                                             }
  2407.  
  2408.                                             if(ToUpper(buf[c])==*getString(CFG_GAD_TYPE_KEY) && maxlist!=0)
  2409.                                             {
  2410.                                                if(FakePress(cyclegadget,CfgWindow,code))
  2411.                                                {
  2412.                                                   if(cfglastnode->Type==WORKBENCH)
  2413.                                                   {
  2414.                                                      cfglastnode->Type=CLI;
  2415.                                                      code=1;
  2416.                                                   }
  2417.                                                   else
  2418.                                                   {
  2419.                                                      cfglastnode->Type=WORKBENCH;
  2420.                                                      code=0;
  2421.                                                   }
  2422.                                                   ActivateNode(cfglastnode);
  2423.                                                }
  2424.                                             }
  2425.                                          }
  2426.                                       }
  2427.                                       break;
  2428.  
  2429.             case IDCMP_NEWSIZE:       RemoveGList(CfgWindow,cfgglist,-1);
  2430.                                       FreeGadgets(cfgglist);
  2431.                                       DisposeObject(getfileimg);
  2432.                                       Move(CfgWindow->RPort,0,0);
  2433.                                       ClearScreen(CfgWindow->RPort);
  2434.                                       RefreshWindowFrame(CfgWindow);
  2435.                                       DrawCfgGUI();
  2436.                                       break;
  2437.  
  2438.             case IDCMP_REFRESHWINDOW: GT_BeginRefresh(CfgWindow);
  2439.                                       GT_EndRefresh(CfgWindow,TRUE);
  2440.          }
  2441.       }
  2442.  
  2443.       if(sigs & wbsigflag)
  2444.       {
  2445.          ProcessWorkbench();
  2446.       }
  2447.  
  2448.       if(sigs & SIGBREAKF_CTRL_C)
  2449.       {
  2450.          if(MayExit())
  2451.          {
  2452.             CleanUpCfg();
  2453.             CleanUpMain();
  2454.             CleanUp(0);
  2455.          }
  2456.       }
  2457.  
  2458.       if(sigs & wbappsigflag)
  2459.       {
  2460.          action=FALSE;
  2461.  
  2462.          while(appmsg = (struct AppMessage *)GetMsg(WBAppPort))
  2463.          {
  2464.             if(appmsg->am_Type == AMTYPE_APPMENUITEM)
  2465.                action=TRUE;
  2466.  
  2467.             if(appmsg->am_Type = AMTYPE_APPWINDOW)
  2468.             {
  2469.                arglist=appmsg->am_ArgList;
  2470.  
  2471.                for(c=0;c<appmsg->am_NumArgs;c++)
  2472.                {
  2473.                   olddir=CurrentDir(arglist->wa_Lock);
  2474.  
  2475.                   if(l=Lock(arglist->wa_Name,SHARED_LOCK))
  2476.                   {
  2477.                      Examine(l,cfgfib);
  2478.  
  2479.                      if(cfgfib->fib_DirEntryType < 0)
  2480.                      {
  2481.                         if(mynode=(struct MyNode *)AllocMem(sizeof(struct MyNode),MEMF_CLEAR))
  2482.                         {
  2483.                            GT_SetGadgetAttrs(listviewgadget,CfgWindow,NULL,GTLV_Labels,~0,TAG_END);
  2484.                            mynode->Stack=4000;
  2485.                            NameFromLock(l,mynode->Command,199);
  2486.                            strncpy(mynode->Name,FilePart(mynode->Command),39);
  2487.                            mynode->Name[39]=0;
  2488.                            mynode->Node.ln_Name=mynode->Name;
  2489.  
  2490.                            if(dobj=GetDiskObject(mynode->Command))
  2491.                            {
  2492.                               mynode->Type=WORKBENCH;
  2493.                               FreeDiskObject(dobj);
  2494.                            }
  2495.                            else
  2496.                            {
  2497.                               mynode->Type=CLI;
  2498.                            }
  2499.  
  2500.                            AddTail(&CommandList,(struct Node *)mynode);
  2501.                            maxlist++;
  2502.                            cfglastitem=maxlist-1;
  2503.                            cfglastnode=CommandList.lh_TailPred;
  2504.                            CfgEnableAll();
  2505.                            GT_SetGadgetAttrs(listviewgadget,CfgWindow,NULL,GTLV_Labels,&CommandList,TAG_END);
  2506.                            GT_SetGadgetAttrs(listviewgadget,CfgWindow,NULL,GTLV_Selected,cfglastitem,TAG_END);
  2507.                            MakeVisible(cfglastitem,cfg_CfgLines,listviewgadget,CfgWindow);
  2508.                            ActivateNode(cfglastnode);
  2509.                            ActivateGadget(namegadget,CfgWindow,NULL);
  2510.                         }
  2511.                         else
  2512.                         {
  2513.                            DisplayBeep(NULL);
  2514.                         }
  2515.                      }
  2516.  
  2517.                      UnLock(l);
  2518.                   }
  2519.  
  2520.                   CurrentDir(olddir);
  2521.                   arglist++;
  2522.                }
  2523.             }
  2524.  
  2525.             ReplyMsg((struct Message *)appmsg);
  2526.          }
  2527.  
  2528.          if(action)
  2529.          {
  2530.             Appear();
  2531.          }
  2532.       }
  2533.  
  2534.       if(sigs & cxsigflag)
  2535.       {
  2536.          HandleCx();
  2537.  
  2538.          if(!CfgWindow)
  2539.             return;
  2540.       }
  2541.    }
  2542. }
  2543.  
  2544. /* Fakepress */
  2545.  
  2546. /*
  2547.  
  2548.    Returns FALSE if the press was interrupted with either shift key,
  2549.    otherwise returns TRUE. The window should have the IDCMP_INACTIVEWINDOW
  2550.    flag set or the routine won't work properly if the window is deactivated
  2551.    before the key is released.
  2552.  
  2553.    Don't forget to specify the _raw_ keycode.
  2554.  
  2555. */
  2556.  
  2557. /* Rawcodes for the shiftkeys */
  2558.  
  2559. #define LEFTSHIFT   0x60
  2560. #define RIGHTSHIFT  0x61
  2561.  
  2562. BOOL FakePress(struct Gadget *gad,struct Window *win,UBYTE rawcode)
  2563. {
  2564.    BOOL kg,res,shift;
  2565.    struct IntuiMessage *msg;
  2566.  
  2567.    /* Draw the selected image */
  2568.  
  2569.    gad->Flags|=GFLG_SELECTED;
  2570.    RefreshGList(gad,win,NULL,1);
  2571.  
  2572.    kg=TRUE;
  2573.    shift=FALSE;
  2574.  
  2575.    /* Main loop */
  2576.  
  2577.    while(kg)
  2578.    {
  2579.       WaitPort(win->UserPort);
  2580.  
  2581.       while(msg=(struct IntuiMessage *)GetMsg(win->UserPort))
  2582.       {
  2583.          /* Key released */
  2584.  
  2585.          if(msg->Class == IDCMP_RAWKEY && msg->Code == rawcode+128)
  2586.          {
  2587.             res=TRUE;
  2588.             kg=FALSE;
  2589.          }
  2590.  
  2591.          /* Shift key pressed */
  2592.  
  2593.          if(msg->Class == IDCMP_RAWKEY && (msg->Code==LEFTSHIFT || msg->Code==RIGHTSHIFT))
  2594.          {
  2595.             shift=TRUE;
  2596.             res=FALSE;
  2597.             kg=FALSE;
  2598.          }
  2599.  
  2600.          /* Window deactivated */
  2601.  
  2602.          if(msg->Class == IDCMP_INACTIVEWINDOW)
  2603.          {
  2604.             res=FALSE;
  2605.             kg=FALSE;
  2606.          }
  2607.  
  2608.          ReplyMsg((struct Message *)msg);
  2609.       }
  2610.    }
  2611.  
  2612.    /* Draw normal image */
  2613.  
  2614.    gad->Flags&=~GFLG_SELECTED;
  2615.    RefreshGList(gad,win,NULL,1);
  2616.  
  2617.    /* Wait for the key to be released if it was aborted with shift */
  2618.  
  2619.    if(shift)
  2620.    {
  2621.       kg=TRUE;
  2622.  
  2623.       while(kg)
  2624.       {
  2625.          WaitPort(win->UserPort);
  2626.  
  2627.          while(msg=(struct IntuiMessage *)GetMsg(win->UserPort))
  2628.          {
  2629.             if(msg->Class == IDCMP_RAWKEY && msg->Code == rawcode+128)
  2630.                kg=FALSE;
  2631.  
  2632.             ReplyMsg((struct Message *)msg);
  2633.          }
  2634.       }
  2635.    }
  2636.  
  2637.    return(res);
  2638. }
  2639.  
  2640. /* LockWindow med busypointer... */
  2641.  
  2642. __chip UWORD WaitPointer[] =
  2643. {
  2644.     0x0000, 0x0000,
  2645.  
  2646.     0x0400, 0x07C0,
  2647.     0x0000, 0x07C0,
  2648.     0x0100, 0x0380,
  2649.     0x0000, 0x07E0,
  2650.     0x07C0, 0x1FF8,
  2651.     0x1FF0, 0x3FEC,
  2652.     0x3FF8, 0x7FDE,
  2653.     0x3FF8, 0x7FBE,
  2654.     0x7FFC, 0xFF7F,
  2655.     0x7EFC, 0xFFFF,
  2656.     0x7FFC, 0xFFFF,
  2657.     0x3FF8, 0x7FFE,
  2658.     0x3FF8, 0x7FFE,
  2659.     0x1FF0, 0x3FFC,
  2660.     0x07C0, 0x1FF8,
  2661.     0x0000, 0x07E0,
  2662.  
  2663.     0x0000, 0x0000,        /* reserved, must be NULL */
  2664. };
  2665.  
  2666. struct MinMaxStruct
  2667. {
  2668.    ULONG MinWidth,MinHeight,MaxWidth,MaxHeight;
  2669. };
  2670.  
  2671. BOOL LockWindow(struct Window *win)
  2672. {
  2673.    struct Requester *req;
  2674.    struct MinMaxStruct *mm;
  2675.  
  2676.    if(!(mm=AllocMem(sizeof(struct MinMaxStruct),MEMF_ANY)))
  2677.    {
  2678.       return(FALSE);
  2679.    }
  2680.  
  2681.    mm->MinWidth=win->MinWidth;
  2682.    mm->MaxWidth=win->MaxWidth;
  2683.    mm->MinHeight=win->MinHeight;
  2684.    mm->MaxHeight=win->MaxHeight;
  2685.  
  2686.    win->UserData=mm;
  2687.  
  2688.    if(!(req=AllocMem(sizeof(struct Requester),MEMF_CLEAR)))
  2689.    {
  2690.       FreeMem(mm,sizeof(struct MinMaxStruct));
  2691.       return(FALSE);
  2692.    }
  2693.  
  2694.    req->Flags=NOREQBACKFILL|SIMPLEREQ;
  2695.  
  2696.    if(!(Request(req,win)))
  2697.    {
  2698.       FreeMem(mm,sizeof(struct MinMaxStruct));
  2699.       FreeMem(req,sizeof(struct Requester));
  2700.       return(FALSE);
  2701.    }
  2702.  
  2703.    if(IntuitionBase->LibNode.lib_Version < 39)
  2704.         SetPointer(win, WaitPointer, 16, 16, -6, 0);
  2705.  
  2706.    else
  2707.       SetWindowPointer(win,WA_BusyPointer,TRUE,TAG_END);
  2708.  
  2709.    WindowLimits(win,win->Width,win->Height,win->Width,win->Height);
  2710.  
  2711.    return(TRUE);
  2712. }
  2713.  
  2714. void UnLockWindow(struct Window *win)
  2715. {
  2716.    struct Requester *req;
  2717.    struct MinMaxStruct *mm;
  2718.  
  2719.    req=win->FirstRequest;
  2720.  
  2721.    if(!req)
  2722.       return;
  2723.  
  2724.    EndRequest(req,win);
  2725.  
  2726.    if(win->UserData)
  2727.    {
  2728.       mm=win->UserData;
  2729.  
  2730. /*
  2731.       win->MinWidth=mm->MinWidth;
  2732.       win->MaxWidth=mm->MaxWidth;
  2733.       win->MinHeight=mm->MinHeight;
  2734.       win->MaxHeight=mm->MaxHeight;
  2735. */
  2736.  
  2737.       WindowLimits(win,mm->MinWidth,mm->MinHeight,mm->MaxWidth,mm->MaxHeight);
  2738.  
  2739.       FreeMem(mm,sizeof(struct MinMaxStruct));
  2740.       win->UserData=NULL;
  2741.    }
  2742.  
  2743.    FreeMem(req,sizeof(struct Requester));
  2744.  
  2745.    ClearPointer(win);
  2746. }
  2747.  
  2748.  
  2749. /* ASL filerequester */
  2750.  
  2751. BOOL OpenAsl(UBYTE *file,UBYTE *title,BOOL save)
  2752. {
  2753.    APTR aslreq;
  2754.    UBYTE path[200],name[100];
  2755.    BOOL res;
  2756.  
  2757.    strcpy(path,file);
  2758.    *PathPart(path)=0;
  2759.  
  2760.    strcpy(name,FilePart(file));
  2761.  
  2762.    aslreq=AllocAslRequestTags(ASL_FileRequest,ASLFR_TitleText,title,
  2763.                                               ASLFR_InitialFile,name,
  2764.                                               ASLFR_InitialDrawer,path,
  2765.                                               ASLFR_DoSaveMode,save,
  2766.                                               ASLFR_RejectIcons,TRUE,TAG_END);
  2767.  
  2768.    if(!aslreq)
  2769.    {
  2770.       DisplayBeep(NULL);
  2771.       return(FALSE);
  2772.    }
  2773.  
  2774.    LockWindow(MainWindow);
  2775.  
  2776.    res=AslRequestTags(aslreq,ASLFR_Window,MainWindow,
  2777.                              TAG_END);
  2778.  
  2779.    UnLockWindow(MainWindow);
  2780.    FreeAslRequest(aslreq);
  2781.  
  2782.    if(res)
  2783.    {
  2784.       strncpy(file,((struct FileRequester *)aslreq)->fr_Drawer,299);
  2785.       file[299]=0;
  2786.       AddPart(file,((struct FileRequester *)aslreq)->fr_File,299);
  2787.    }
  2788.  
  2789.    return(res);
  2790. }
  2791.  
  2792.  
  2793.  
  2794. /*
  2795.  
  2796.  
  2797. Snott:
  2798. ------
  2799. Yak OpenWindow
  2800. ListViewTop (Bryce Dawson)
  2801. Commodity startup
  2802. WorkbenchRun
  2803. GTB
  2804. WB2CLI
  2805.  
  2806. Features:
  2807. ---------
  2808. Cursor keys/Numpad
  2809. Open on pubscreen
  2810. CON: on pubscreen
  2811. Öppnar under muspekaren
  2812. Resizable listview och config
  2813. Lokaliserad
  2814. %s passing
  2815. AppMenu
  2816. Config
  2817. AppWindow
  2818.  
  2819. Beta 2
  2820. ------
  2821. Klarar nu 200 tecken långa kommandon
  2822. Menyer
  2823. Stack
  2824. Kommer ihåg senaste
  2825.  Öppna/Stäng gränssnitt funkar
  2826.  Om man trycker hotkeyn/startar programmet/väljer Visa gränssnitt så flyttas
  2827.  ett redan öppnat gränssnitt fram
  2828. Öppnar nu requesters på rätt skärm
  2829. PgUp/PgDn/End/Home/Up/Down
  2830.  
  2831. Beta 3
  2832. ------
  2833. CopyPath
  2834. 2.04-kompatibelt
  2835. AppMenu
  2836. Äntligen kompatibelt med 2.04
  2837. Config
  2838. Tar hänsyn till ToolType:n TOOLPRI
  2839.  
  2840. Beta 4
  2841. ------
  2842. Bättre simulering av tangentbordet
  2843. Går ej att resiza när fönstret är låst
  2844.  
  2845. */
  2846.  
  2847.  
  2848.  
  2849. /*
  2850.  
  2851. Nästa version:
  2852. --------------
  2853. Multithreaded
  2854. Flera listor
  2855. Alt-Tab byta skärm för fönstret
  2856.  
  2857. Öppna lista från lista
  2858.    Enskilda hotkeys för oliak entries
  2859.    FirstScreen istället för ActiveScreen
  2860.  
  2861.    Kolla hotkey när den skrivs...
  2862.    Center...
  2863.  
  2864.    leta efter config på andra ställen
  2865.    Installerscript
  2866.  
  2867.    Lockup vid start med falsk hotkey och sen start? Hmm. Felaktig config finns.
  2868.    Kolla språk
  2869. */
  2870.